1 /* $OpenBSD: proc.c,v 1.17 2020/05/16 16:07:55 nicm Exp $ */ 2 3 /* 4 * Copyright (c) 2015 Nicholas Marriott <nicholas.marriott@gmail.com> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER 15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <sys/types.h> 20 #include <sys/queue.h> 21 #include <sys/uio.h> 22 #include <sys/utsname.h> 23 24 #include <errno.h> 25 #include <event.h> 26 #include <imsg.h> 27 #include <signal.h> 28 #include <stdlib.h> 29 #include <string.h> 30 #include <unistd.h> 31 32 #include "tmux.h" 33 34 struct tmuxproc { 35 const char *name; 36 int exit; 37 38 void (*signalcb)(int); 39 40 struct event ev_sigint; 41 struct event ev_sighup; 42 struct event ev_sigchld; 43 struct event ev_sigcont; 44 struct event ev_sigterm; 45 struct event ev_sigusr1; 46 struct event ev_sigusr2; 47 struct event ev_sigwinch; 48 }; 49 50 struct tmuxpeer { 51 struct tmuxproc *parent; 52 53 struct imsgbuf ibuf; 54 struct event event; 55 56 int flags; 57 #define PEER_BAD 0x1 58 59 void (*dispatchcb)(struct imsg *, void *); 60 void *arg; 61 }; 62 63 static int peer_check_version(struct tmuxpeer *, struct imsg *); 64 static void proc_update_event(struct tmuxpeer *); 65 66 static void 67 proc_event_cb(__unused int fd, short events, void *arg) 68 { 69 struct tmuxpeer *peer = arg; 70 ssize_t n; 71 struct imsg imsg; 72 73 if (!(peer->flags & PEER_BAD) && (events & EV_READ)) { 74 if (((n = imsg_read(&peer->ibuf)) == -1 && errno != EAGAIN) || 75 n == 0) { 76 peer->dispatchcb(NULL, peer->arg); 77 return; 78 } 79 for (;;) { 80 if ((n = imsg_get(&peer->ibuf, &imsg)) == -1) { 81 peer->dispatchcb(NULL, peer->arg); 82 return; 83 } 84 if (n == 0) 85 break; 86 log_debug("peer %p message %d", peer, imsg.hdr.type); 87 88 if (peer_check_version(peer, &imsg) != 0) { 89 if (imsg.fd != -1) 90 close(imsg.fd); 91 imsg_free(&imsg); 92 break; 93 } 94 95 peer->dispatchcb(&imsg, peer->arg); 96 imsg_free(&imsg); 97 } 98 } 99 100 if (events & EV_WRITE) { 101 if (msgbuf_write(&peer->ibuf.w) <= 0 && errno != EAGAIN) { 102 peer->dispatchcb(NULL, peer->arg); 103 return; 104 } 105 } 106 107 if ((peer->flags & PEER_BAD) && peer->ibuf.w.queued == 0) { 108 peer->dispatchcb(NULL, peer->arg); 109 return; 110 } 111 112 proc_update_event(peer); 113 } 114 115 static void 116 proc_signal_cb(int signo, __unused short events, void *arg) 117 { 118 struct tmuxproc *tp = arg; 119 120 tp->signalcb(signo); 121 } 122 123 static int 124 peer_check_version(struct tmuxpeer *peer, struct imsg *imsg) 125 { 126 int version; 127 128 version = imsg->hdr.peerid & 0xff; 129 if (imsg->hdr.type != MSG_VERSION && version != PROTOCOL_VERSION) { 130 log_debug("peer %p bad version %d", peer, version); 131 132 proc_send(peer, MSG_VERSION, -1, NULL, 0); 133 peer->flags |= PEER_BAD; 134 135 return (-1); 136 } 137 return (0); 138 } 139 140 static void 141 proc_update_event(struct tmuxpeer *peer) 142 { 143 short events; 144 145 event_del(&peer->event); 146 147 events = EV_READ; 148 if (peer->ibuf.w.queued > 0) 149 events |= EV_WRITE; 150 event_set(&peer->event, peer->ibuf.fd, events, proc_event_cb, peer); 151 152 event_add(&peer->event, NULL); 153 } 154 155 int 156 proc_send(struct tmuxpeer *peer, enum msgtype type, int fd, const void *buf, 157 size_t len) 158 { 159 struct imsgbuf *ibuf = &peer->ibuf; 160 void *vp = (void *)buf; 161 int retval; 162 163 if (peer->flags & PEER_BAD) 164 return (-1); 165 log_debug("sending message %d to peer %p (%zu bytes)", type, peer, len); 166 167 retval = imsg_compose(ibuf, type, PROTOCOL_VERSION, -1, fd, vp, len); 168 if (retval != 1) 169 return (-1); 170 proc_update_event(peer); 171 return (0); 172 } 173 174 struct tmuxproc * 175 proc_start(const char *name) 176 { 177 struct tmuxproc *tp; 178 struct utsname u; 179 180 log_open(name); 181 setproctitle("%s (%s)", name, socket_path); 182 183 if (uname(&u) < 0) 184 memset(&u, 0, sizeof u); 185 186 log_debug("%s started (%ld): version %s, socket %s, protocol %d", name, 187 (long)getpid(), getversion(), socket_path, PROTOCOL_VERSION); 188 log_debug("on %s %s %s; libevent %s (%s)", u.sysname, u.release, 189 u.version, event_get_version(), event_get_method()); 190 191 tp = xcalloc(1, sizeof *tp); 192 tp->name = xstrdup(name); 193 194 return (tp); 195 } 196 197 void 198 proc_loop(struct tmuxproc *tp, int (*loopcb)(void)) 199 { 200 log_debug("%s loop enter", tp->name); 201 do 202 event_loop(EVLOOP_ONCE); 203 while (!tp->exit && (loopcb == NULL || !loopcb ())); 204 log_debug("%s loop exit", tp->name); 205 } 206 207 void 208 proc_exit(struct tmuxproc *tp) 209 { 210 tp->exit = 1; 211 } 212 213 void 214 proc_set_signals(struct tmuxproc *tp, void (*signalcb)(int)) 215 { 216 struct sigaction sa; 217 218 tp->signalcb = signalcb; 219 220 memset(&sa, 0, sizeof sa); 221 sigemptyset(&sa.sa_mask); 222 sa.sa_flags = SA_RESTART; 223 sa.sa_handler = SIG_IGN; 224 225 sigaction(SIGPIPE, &sa, NULL); 226 sigaction(SIGTSTP, &sa, NULL); 227 sigaction(SIGTTIN, &sa, NULL); 228 sigaction(SIGTTOU, &sa, NULL); 229 230 signal_set(&tp->ev_sigint, SIGINT, proc_signal_cb, tp); 231 signal_add(&tp->ev_sigint, NULL); 232 signal_set(&tp->ev_sighup, SIGHUP, proc_signal_cb, tp); 233 signal_add(&tp->ev_sighup, NULL); 234 signal_set(&tp->ev_sigchld, SIGCHLD, proc_signal_cb, tp); 235 signal_add(&tp->ev_sigchld, NULL); 236 signal_set(&tp->ev_sigcont, SIGCONT, proc_signal_cb, tp); 237 signal_add(&tp->ev_sigcont, NULL); 238 signal_set(&tp->ev_sigterm, SIGTERM, proc_signal_cb, tp); 239 signal_add(&tp->ev_sigterm, NULL); 240 signal_set(&tp->ev_sigusr1, SIGUSR1, proc_signal_cb, tp); 241 signal_add(&tp->ev_sigusr1, NULL); 242 signal_set(&tp->ev_sigusr2, SIGUSR2, proc_signal_cb, tp); 243 signal_add(&tp->ev_sigusr2, NULL); 244 signal_set(&tp->ev_sigwinch, SIGWINCH, proc_signal_cb, tp); 245 signal_add(&tp->ev_sigwinch, NULL); 246 } 247 248 void 249 proc_clear_signals(struct tmuxproc *tp, int defaults) 250 { 251 struct sigaction sa; 252 253 memset(&sa, 0, sizeof sa); 254 sigemptyset(&sa.sa_mask); 255 sa.sa_flags = SA_RESTART; 256 sa.sa_handler = SIG_DFL; 257 258 sigaction(SIGPIPE, &sa, NULL); 259 sigaction(SIGTSTP, &sa, NULL); 260 261 signal_del(&tp->ev_sigint); 262 signal_del(&tp->ev_sighup); 263 signal_del(&tp->ev_sigchld); 264 signal_del(&tp->ev_sigcont); 265 signal_del(&tp->ev_sigterm); 266 signal_del(&tp->ev_sigusr1); 267 signal_del(&tp->ev_sigusr2); 268 signal_del(&tp->ev_sigwinch); 269 270 if (defaults) { 271 sigaction(SIGINT, &sa, NULL); 272 sigaction(SIGHUP, &sa, NULL); 273 sigaction(SIGCHLD, &sa, NULL); 274 sigaction(SIGCONT, &sa, NULL); 275 sigaction(SIGTERM, &sa, NULL); 276 sigaction(SIGUSR1, &sa, NULL); 277 sigaction(SIGUSR2, &sa, NULL); 278 sigaction(SIGWINCH, &sa, NULL); 279 } 280 } 281 282 struct tmuxpeer * 283 proc_add_peer(struct tmuxproc *tp, int fd, 284 void (*dispatchcb)(struct imsg *, void *), void *arg) 285 { 286 struct tmuxpeer *peer; 287 288 peer = xcalloc(1, sizeof *peer); 289 peer->parent = tp; 290 291 peer->dispatchcb = dispatchcb; 292 peer->arg = arg; 293 294 imsg_init(&peer->ibuf, fd); 295 event_set(&peer->event, fd, EV_READ, proc_event_cb, peer); 296 297 log_debug("add peer %p: %d (%p)", peer, fd, arg); 298 299 proc_update_event(peer); 300 return (peer); 301 } 302 303 void 304 proc_remove_peer(struct tmuxpeer *peer) 305 { 306 log_debug("remove peer %p", peer); 307 308 event_del(&peer->event); 309 imsg_clear(&peer->ibuf); 310 311 close(peer->ibuf.fd); 312 free(peer); 313 } 314 315 void 316 proc_kill_peer(struct tmuxpeer *peer) 317 { 318 peer->flags |= PEER_BAD; 319 } 320 321 void 322 proc_toggle_log(struct tmuxproc *tp) 323 { 324 log_toggle(tp->name); 325 } 326