tmux/proc.c
Nicholas Marriott 0f308bd18f imsg no longer associates file descriptors with the imsg they were sent with,
work around this for the moment (it is not clear if this is intentional).
2024-11-22 09:58:47 +00:00

407 lines
8.7 KiB
C

/* $OpenBSD$ */
/*
* Copyright (c) 2015 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/utsname.h>
#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#if defined(HAVE_NCURSES_H)
#include <ncurses.h>
#endif
#include "tmux.h"
struct tmuxproc {
const char *name;
int exit;
void (*signalcb)(int);
struct event ev_sigint;
struct event ev_sighup;
struct event ev_sigchld;
struct event ev_sigcont;
struct event ev_sigterm;
struct event ev_sigusr1;
struct event ev_sigusr2;
struct event ev_sigwinch;
TAILQ_HEAD(, tmuxpeer) peers;
};
struct tmuxpeer {
struct tmuxproc *parent;
struct imsgbuf ibuf;
int lastfd;
struct event event;
uid_t uid;
int flags;
#define PEER_BAD 0x1
void (*dispatchcb)(struct imsg *, void *);
void *arg;
TAILQ_ENTRY(tmuxpeer) entry;
};
static int peer_check_version(struct tmuxpeer *, struct imsg *);
static void proc_update_event(struct tmuxpeer *);
static void
proc_event_cb(int fd, short events, void *arg)
{
struct tmuxpeer *peer = arg;
ssize_t n;
struct imsg imsg;
if (!(peer->flags & PEER_BAD) && (events & EV_READ)) {
if (imsgbuf_read(&peer->ibuf) != 1) {
peer->dispatchcb(NULL, peer->arg);
return;
}
for (;;) {
if ((n = imsg_get(&peer->ibuf, &imsg)) == -1) {
peer->dispatchcb(NULL, peer->arg);
return;
}
if (n == 0)
break;
fd = imsg_get_fd(&imsg);
log_debug("peer %p message %d fd %d", peer,
imsg.hdr.type, fd);
if (fd != -1) {
if (peer->lastfd != -1)
close(peer->lastfd);
peer->lastfd = fd;
}
if (peer_check_version(peer, &imsg) != 0) {
imsg_free(&imsg);
break;
}
peer->dispatchcb(&imsg, peer->arg);
imsg_free(&imsg);
}
}
if (events & EV_WRITE) {
if (imsgbuf_write(&peer->ibuf) == -1) {
peer->dispatchcb(NULL, peer->arg);
return;
}
}
if ((peer->flags & PEER_BAD) && imsgbuf_queuelen(&peer->ibuf) == 0) {
peer->dispatchcb(NULL, peer->arg);
return;
}
proc_update_event(peer);
}
static void
proc_signal_cb(int signo, __unused short events, void *arg)
{
struct tmuxproc *tp = arg;
tp->signalcb(signo);
}
static int
peer_check_version(struct tmuxpeer *peer, struct imsg *imsg)
{
int version;
version = imsg->hdr.peerid & 0xff;
if (imsg->hdr.type != MSG_VERSION && version != PROTOCOL_VERSION) {
log_debug("peer %p bad version %d", peer, version);
proc_send(peer, MSG_VERSION, -1, NULL, 0);
peer->flags |= PEER_BAD;
return (-1);
}
return (0);
}
static void
proc_update_event(struct tmuxpeer *peer)
{
short events;
event_del(&peer->event);
events = EV_READ;
if (imsgbuf_queuelen(&peer->ibuf) > 0)
events |= EV_WRITE;
event_set(&peer->event, peer->ibuf.fd, events, proc_event_cb, peer);
event_add(&peer->event, NULL);
}
int
proc_send(struct tmuxpeer *peer, enum msgtype type, int fd, const void *buf,
size_t len)
{
struct imsgbuf *ibuf = &peer->ibuf;
void *vp = (void *)buf;
int retval;
if (peer->flags & PEER_BAD)
return (-1);
log_debug("sending message %d to peer %p (%zu bytes)", type, peer, len);
retval = imsg_compose(ibuf, type, PROTOCOL_VERSION, -1, fd, vp, len);
if (retval != 1)
return (-1);
proc_update_event(peer);
return (0);
}
struct tmuxproc *
proc_start(const char *name)
{
struct tmuxproc *tp;
struct utsname u;
log_open(name);
setproctitle("%s (%s)", name, socket_path);
if (uname(&u) < 0)
memset(&u, 0, sizeof u);
log_debug("%s started (%ld): version %s, socket %s, protocol %d", name,
(long)getpid(), getversion(), socket_path, PROTOCOL_VERSION);
log_debug("on %s %s %s", u.sysname, u.release, u.version);
log_debug("using libevent %s %s", event_get_version(), event_get_method());
#ifdef HAVE_UTF8PROC
log_debug("using utf8proc %s", utf8proc_version());
#endif
#ifdef NCURSES_VERSION
log_debug("using ncurses %s %06u", NCURSES_VERSION, NCURSES_VERSION_PATCH);
#endif
tp = xcalloc(1, sizeof *tp);
tp->name = xstrdup(name);
TAILQ_INIT(&tp->peers);
return (tp);
}
void
proc_loop(struct tmuxproc *tp, int (*loopcb)(void))
{
log_debug("%s loop enter", tp->name);
do
event_loop(EVLOOP_ONCE);
while (!tp->exit && (loopcb == NULL || !loopcb ()));
log_debug("%s loop exit", tp->name);
}
void
proc_exit(struct tmuxproc *tp)
{
struct tmuxpeer *peer;
TAILQ_FOREACH(peer, &tp->peers, entry)
imsgbuf_flush(&peer->ibuf);
tp->exit = 1;
}
void
proc_set_signals(struct tmuxproc *tp, void (*signalcb)(int))
{
struct sigaction sa;
tp->signalcb = signalcb;
memset(&sa, 0, sizeof sa);
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sa, NULL);
sigaction(SIGTSTP, &sa, NULL);
sigaction(SIGTTIN, &sa, NULL);
sigaction(SIGTTOU, &sa, NULL);
sigaction(SIGQUIT, &sa, NULL);
signal_set(&tp->ev_sigint, SIGINT, proc_signal_cb, tp);
signal_add(&tp->ev_sigint, NULL);
signal_set(&tp->ev_sighup, SIGHUP, proc_signal_cb, tp);
signal_add(&tp->ev_sighup, NULL);
signal_set(&tp->ev_sigchld, SIGCHLD, proc_signal_cb, tp);
signal_add(&tp->ev_sigchld, NULL);
signal_set(&tp->ev_sigcont, SIGCONT, proc_signal_cb, tp);
signal_add(&tp->ev_sigcont, NULL);
signal_set(&tp->ev_sigterm, SIGTERM, proc_signal_cb, tp);
signal_add(&tp->ev_sigterm, NULL);
signal_set(&tp->ev_sigusr1, SIGUSR1, proc_signal_cb, tp);
signal_add(&tp->ev_sigusr1, NULL);
signal_set(&tp->ev_sigusr2, SIGUSR2, proc_signal_cb, tp);
signal_add(&tp->ev_sigusr2, NULL);
signal_set(&tp->ev_sigwinch, SIGWINCH, proc_signal_cb, tp);
signal_add(&tp->ev_sigwinch, NULL);
}
void
proc_clear_signals(struct tmuxproc *tp, int defaults)
{
struct sigaction sa;
memset(&sa, 0, sizeof sa);
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
sa.sa_handler = SIG_DFL;
sigaction(SIGPIPE, &sa, NULL);
sigaction(SIGTSTP, &sa, NULL);
signal_del(&tp->ev_sigint);
signal_del(&tp->ev_sighup);
signal_del(&tp->ev_sigchld);
signal_del(&tp->ev_sigcont);
signal_del(&tp->ev_sigterm);
signal_del(&tp->ev_sigusr1);
signal_del(&tp->ev_sigusr2);
signal_del(&tp->ev_sigwinch);
if (defaults) {
sigaction(SIGINT, &sa, NULL);
sigaction(SIGQUIT, &sa, NULL);
sigaction(SIGHUP, &sa, NULL);
sigaction(SIGCHLD, &sa, NULL);
sigaction(SIGCONT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGUSR1, &sa, NULL);
sigaction(SIGUSR2, &sa, NULL);
sigaction(SIGWINCH, &sa, NULL);
}
}
struct tmuxpeer *
proc_add_peer(struct tmuxproc *tp, int fd,
void (*dispatchcb)(struct imsg *, void *), void *arg)
{
struct tmuxpeer *peer;
gid_t gid;
peer = xcalloc(1, sizeof *peer);
peer->parent = tp;
peer->lastfd = -1;
peer->dispatchcb = dispatchcb;
peer->arg = arg;
if (imsgbuf_init(&peer->ibuf, fd) == -1)
fatal("imsgbuf_init");
imsgbuf_allow_fdpass(&peer->ibuf);
event_set(&peer->event, fd, EV_READ, proc_event_cb, peer);
if (getpeereid(fd, &peer->uid, &gid) != 0)
peer->uid = (uid_t)-1;
log_debug("add peer %p: %d (%p)", peer, fd, arg);
TAILQ_INSERT_TAIL(&tp->peers, peer, entry);
proc_update_event(peer);
return (peer);
}
void
proc_remove_peer(struct tmuxpeer *peer)
{
TAILQ_REMOVE(&peer->parent->peers, peer, entry);
log_debug("remove peer %p", peer);
event_del(&peer->event);
imsgbuf_clear(&peer->ibuf);
if (peer->lastfd != -1)
close(peer->lastfd);
close(peer->ibuf.fd);
free(peer);
}
void
proc_kill_peer(struct tmuxpeer *peer)
{
peer->flags |= PEER_BAD;
}
void
proc_flush_peer(struct tmuxpeer *peer)
{
imsgbuf_flush(&peer->ibuf);
}
void
proc_toggle_log(struct tmuxproc *tp)
{
log_toggle(tp->name);
}
pid_t
proc_fork_and_daemon(int *fd)
{
pid_t pid;
int pair[2];
if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pair) != 0)
fatal("socketpair failed");
switch (pid = fork()) {
case -1:
fatal("fork failed");
case 0:
close(pair[0]);
*fd = pair[1];
if (daemon(1, 0) != 0)
fatal("daemon failed");
return (0);
default:
close(pair[1]);
*fd = pair[0];
return (pid);
}
}
uid_t
proc_get_peer_uid(struct tmuxpeer *peer)
{
return (peer->uid);
}
int
proc_get_last_fd(struct tmuxpeer *peer)
{
int fd = peer->lastfd;
peer->lastfd = -1;
return (fd);
}