1 /*	$OpenBSD: control.c,v 1.65 2026/03/02 19:28:01 rsadowski Exp $	*/
2 
3 /*
4  * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
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 USE, DATA OR PROFITS, WHETHER IN AN
15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17  */
18 
19 #include <sys/queue.h>
20 #include <sys/stat.h>
21 #include <sys/socket.h>
22 #include <sys/time.h>
23 #include <sys/un.h>
24 
25 #include <errno.h>
26 #include <event.h>
27 #include <fcntl.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <unistd.h>
31 #include <imsg.h>
32 
33 #include "relayd.h"
34 #include "log.h"
35 
36 #define	CONTROL_BACKLOG	5
37 
38 struct ctl_connlist ctl_conns = TAILQ_HEAD_INITIALIZER(ctl_conns);
39 
40 void		 control_accept(int, short, void *);
41 void		 control_close(int, struct control_sock *);
42 
43 int
44 control_init(struct privsep *ps, struct control_sock *cs)
45 {
46 	struct relayd		*env = ps->ps_env;
47 	struct sockaddr_un	 sun;
48 	int			 fd;
49 	mode_t			 old_umask, mode;
50 
51 	if (cs->cs_name == NULL)
52 		return (0);
53 
54 	if ((fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0)) == -1) {
55 		log_warn("%s: socket", __func__);
56 		return (-1);
57 	}
58 
59 	sun.sun_family = AF_UNIX;
60 	if (strlcpy(sun.sun_path, cs->cs_name,
61 	    sizeof(sun.sun_path)) >= sizeof(sun.sun_path)) {
62 		log_warn("%s: %s name too long", __func__, cs->cs_name);
63 		close(fd);
64 		return (-1);
65 	}
66 
67 	if (unlink(cs->cs_name) == -1)
68 		if (errno != ENOENT) {
69 			log_warn("%s: unlink %s", __func__, cs->cs_name);
70 			close(fd);
71 			return (-1);
72 		}
73 
74 	if (cs->cs_restricted) {
75 		old_umask = umask(S_IXUSR|S_IXGRP|S_IXOTH);
76 		mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH;
77 	} else {
78 		old_umask = umask(S_IXUSR|S_IXGRP|S_IWOTH|S_IROTH|S_IXOTH);
79 		mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP;
80 	}
81 
82 	if (bind(fd, (struct sockaddr *)&sun, sizeof(sun)) == -1) {
83 		log_warn("%s: bind: %s", __func__, cs->cs_name);
84 		close(fd);
85 		(void)umask(old_umask);
86 		return (-1);
87 	}
88 	(void)umask(old_umask);
89 
90 	if (chmod(cs->cs_name, mode) == -1) {
91 		log_warn("%s: chmod", __func__);
92 		close(fd);
93 		(void)unlink(cs->cs_name);
94 		return (-1);
95 	}
96 
97 	cs->cs_fd = fd;
98 	cs->cs_env = env;
99 
100 	return (0);
101 }
102 
103 int
104 control_listen(struct control_sock *cs)
105 {
106 	if (cs->cs_name == NULL)
107 		return (0);
108 
109 	if (listen(cs->cs_fd, CONTROL_BACKLOG) == -1) {
110 		log_warn("%s: listen", __func__);
111 		return (-1);
112 	}
113 
114 	event_set(&cs->cs_ev, cs->cs_fd, EV_READ,
115 	    control_accept, cs);
116 	event_add(&cs->cs_ev, NULL);
117 	evtimer_set(&cs->cs_evt, control_accept, cs);
118 
119 	return (0);
120 }
121 
122 void
123 control_cleanup(struct control_sock *cs)
124 {
125 	if (cs->cs_name == NULL)
126 		return;
127 	event_del(&cs->cs_ev);
128 	event_del(&cs->cs_evt);
129 }
130 
131 void
132 control_accept(int listenfd, short event, void *arg)
133 {
134 	int			 connfd;
135 	socklen_t		 len;
136 	struct sockaddr_un	 sun;
137 	struct ctl_conn		*c;
138 	struct control_sock	*cs = arg;
139 
140 	event_add(&cs->cs_ev, NULL);
141 	if ((event & EV_TIMEOUT))
142 		return;
143 
144 	len = sizeof(sun);
145 	if ((connfd = accept4(listenfd,
146 	    (struct sockaddr *)&sun, &len, SOCK_NONBLOCK)) == -1) {
147 		/*
148 		 * Pause accept if we are out of file descriptors, or
149 		 * libevent will haunt us here too.
150 		 */
151 		if (errno == ENFILE || errno == EMFILE) {
152 			struct timeval evtpause = { 1, 0 };
153 
154 			event_del(&cs->cs_ev);
155 			evtimer_add(&cs->cs_evt, &evtpause);
156 		} else if (errno != EWOULDBLOCK && errno != EINTR &&
157 		    errno != ECONNABORTED)
158 			log_warn("%s: accept", __func__);
159 		return;
160 	}
161 
162 	if ((c = calloc(1, sizeof(struct ctl_conn))) == NULL) {
163 		log_warn("%s: calloc", __func__);
164 		close(connfd);
165 		return;
166 	}
167 
168 	if (imsgbuf_init(&c->iev.ibuf, connfd) == -1) {
169 		log_warn("%s: imsgbuf_init", __func__);
170 		close(connfd);
171 		free(c);
172 		return;
173 	}
174 
175 	c->iev.handler = control_dispatch_imsg;
176 	c->iev.events = EV_READ;
177 	c->iev.data = cs;	/* proc.c cheats (reuses the handler) */
178 	event_set(&c->iev.ev, c->iev.ibuf.fd, c->iev.events,
179 	    c->iev.handler, cs);
180 	event_add(&c->iev.ev, NULL);
181 
182 	TAILQ_INSERT_TAIL(&ctl_conns, c, entry);
183 }
184 
185 struct ctl_conn *
186 control_connbyfd(int fd)
187 {
188 	struct ctl_conn	*c;
189 
190 	TAILQ_FOREACH(c, &ctl_conns, entry) {
191 		if (c->iev.ibuf.fd == fd)
192 			break;
193 	}
194 
195 	return (c);
196 }
197 
198 void
199 control_close(int fd, struct control_sock *cs)
200 {
201 	struct ctl_conn	*c;
202 
203 	if ((c = control_connbyfd(fd)) == NULL) {
204 		log_warn("%s: fd %d not found", __func__, fd);
205 		return;
206 	}
207 
208 	imsgbuf_clear(&c->iev.ibuf);
209 	TAILQ_REMOVE(&ctl_conns, c, entry);
210 
211 	event_del(&c->iev.ev);
212 	close(c->iev.ibuf.fd);
213 
214 	/* Some file descriptors are available again. */
215 	if (evtimer_pending(&cs->cs_evt, NULL)) {
216 		evtimer_del(&cs->cs_evt);
217 		event_add(&cs->cs_ev, NULL);
218 	}
219 
220 	free(c);
221 }
222 
223 void
224 control_dispatch_imsg(int fd, short event, void *arg)
225 {
226 	struct control_sock	*cs = arg;
227 	struct ctl_conn		*c;
228 	struct imsg		 imsg;
229 	struct ctl_id		 id;
230 	int			 n;
231 	int			 verbose;
232 	struct relayd		*env = cs->cs_env;
233 	struct privsep		*ps = env->sc_ps;
234 
235 	if ((c = control_connbyfd(fd)) == NULL) {
236 		log_warn("%s: fd %d not found", __func__, fd);
237 		return;
238 	}
239 
240 	if (event & EV_READ) {
241 		if (imsgbuf_read(&c->iev.ibuf) != 1) {
242 			control_close(fd, cs);
243 			return;
244 		}
245 	}
246 
247 	if (event & EV_WRITE) {
248 		if (imsgbuf_write(&c->iev.ibuf) == -1) {
249 			control_close(fd, cs);
250 			return;
251 		}
252 	}
253 
254 	for (;;) {
255 		if ((n = imsg_get(&c->iev.ibuf, &imsg)) == -1) {
256 			control_close(fd, cs);
257 			return;
258 		}
259 
260 		if (n == 0)
261 			break;
262 
263 		if (c->waiting) {
264 			log_debug("%s: unexpected imsg %d",
265 			    __func__, imsg.hdr.type);
266 			imsg_free(&imsg);
267 			control_close(fd, cs);
268 			return;
269 		}
270 
271 		switch (imsg.hdr.type) {
272 		case IMSG_CTL_SHOW_SUM:
273 			show(c);
274 			break;
275 		case IMSG_CTL_SESSION:
276 			show_sessions(c);
277 			break;
278 		case IMSG_CTL_RDR_DISABLE:
279 			if (imsg.hdr.len != IMSG_HEADER_SIZE + sizeof(id))
280 				fatalx("invalid imsg header len");
281 			memcpy(&id, imsg.data, sizeof(id));
282 			if (disable_rdr(c, &id))
283 				imsg_compose_event(&c->iev, IMSG_CTL_FAIL,
284 				    0, ps->ps_instance + 1, -1, NULL, 0);
285 			else {
286 				memcpy(imsg.data, &id, sizeof(id));
287 				control_imsg_forward(ps, &imsg);
288 				imsg_compose_event(&c->iev, IMSG_CTL_OK,
289 				    0, ps->ps_instance + 1, -1, NULL, 0);
290 			}
291 			break;
292 		case IMSG_CTL_RDR_ENABLE:
293 			if (imsg.hdr.len != IMSG_HEADER_SIZE + sizeof(id))
294 				fatalx("invalid imsg header len");
295 			memcpy(&id, imsg.data, sizeof(id));
296 			if (enable_rdr(c, &id))
297 				imsg_compose_event(&c->iev, IMSG_CTL_FAIL,
298 				    0, ps->ps_instance + 1, -1, NULL, 0);
299 			else {
300 				memcpy(imsg.data, &id, sizeof(id));
301 				control_imsg_forward(ps, &imsg);
302 				imsg_compose_event(&c->iev, IMSG_CTL_OK,
303 				    0, ps->ps_instance + 1, -1, NULL, 0);
304 			}
305 			break;
306 		case IMSG_CTL_TABLE_DISABLE:
307 			if (imsg.hdr.len != IMSG_HEADER_SIZE + sizeof(id))
308 				fatalx("invalid imsg header len");
309 			memcpy(&id, imsg.data, sizeof(id));
310 			if (disable_table(c, &id))
311 				imsg_compose_event(&c->iev, IMSG_CTL_FAIL,
312 				    0, ps->ps_instance + 1, -1, NULL, 0);
313 			else {
314 				memcpy(imsg.data, &id, sizeof(id));
315 				control_imsg_forward(ps, &imsg);
316 				imsg_compose_event(&c->iev, IMSG_CTL_OK,
317 				    0, ps->ps_instance + 1, -1, NULL, 0);
318 			}
319 			break;
320 		case IMSG_CTL_TABLE_ENABLE:
321 			if (imsg.hdr.len != IMSG_HEADER_SIZE + sizeof(id))
322 				fatalx("invalid imsg header len");
323 			memcpy(&id, imsg.data, sizeof(id));
324 			if (enable_table(c, &id))
325 				imsg_compose_event(&c->iev, IMSG_CTL_FAIL,
326 				    0, ps->ps_instance + 1, -1, NULL, 0);
327 			else {
328 				memcpy(imsg.data, &id, sizeof(id));
329 				control_imsg_forward(ps, &imsg);
330 				imsg_compose_event(&c->iev, IMSG_CTL_OK,
331 				    0, ps->ps_instance + 1, -1, NULL, 0);
332 			}
333 			break;
334 		case IMSG_CTL_HOST_DISABLE:
335 			if (imsg.hdr.len != IMSG_HEADER_SIZE + sizeof(id))
336 				fatalx("invalid imsg header len");
337 			memcpy(&id, imsg.data, sizeof(id));
338 			if (disable_host(c, &id, NULL))
339 				imsg_compose_event(&c->iev, IMSG_CTL_FAIL,
340 				    0, ps->ps_instance + 1, -1, NULL, 0);
341 			else {
342 				memcpy(imsg.data, &id, sizeof(id));
343 				control_imsg_forward(ps, &imsg);
344 				imsg_compose_event(&c->iev, IMSG_CTL_OK,
345 				    0, ps->ps_instance + 1, -1, NULL, 0);
346 			}
347 			break;
348 		case IMSG_CTL_HOST_ENABLE:
349 			if (imsg.hdr.len != IMSG_HEADER_SIZE + sizeof(id))
350 				fatalx("invalid imsg header len");
351 			memcpy(&id, imsg.data, sizeof(id));
352 			if (enable_host(c, &id, NULL))
353 				imsg_compose_event(&c->iev, IMSG_CTL_FAIL,
354 				    0, ps->ps_instance + 1, -1, NULL, 0);
355 			else {
356 				memcpy(imsg.data, &id, sizeof(id));
357 				control_imsg_forward(ps, &imsg);
358 				imsg_compose_event(&c->iev, IMSG_CTL_OK,
359 				    0, ps->ps_instance + 1, -1, NULL, 0);
360 			}
361 			break;
362 		case IMSG_CTL_SHUTDOWN:
363 		case IMSG_CTL_RELOAD:
364 			proc_forward_imsg(env->sc_ps, &imsg, PROC_PARENT, -1);
365 			break;
366 		case IMSG_CTL_POLL:
367 			proc_compose(env->sc_ps, PROC_HCE,
368 			    IMSG_CTL_POLL, NULL, 0);
369 			imsg_compose_event(&c->iev, IMSG_CTL_OK,
370 			    0, ps->ps_instance + 1, -1, NULL, 0);
371 			break;
372 		case IMSG_CTL_NOTIFY:
373 			if (c->flags & CTL_CONN_NOTIFY) {
374 				log_debug("%s: "
375 				    "client requested notify more than once",
376 				    __func__);
377 				imsg_compose_event(&c->iev, IMSG_CTL_FAIL,
378 				    0, ps->ps_instance + 1, -1, NULL, 0);
379 				break;
380 			}
381 			c->flags |= CTL_CONN_NOTIFY;
382 			break;
383 		case IMSG_CTL_VERBOSE:
384 			IMSG_SIZE_CHECK(&imsg, &verbose);
385 
386 			memcpy(&verbose, imsg.data, sizeof(verbose));
387 
388 			proc_forward_imsg(env->sc_ps, &imsg, PROC_PARENT, -1);
389 			proc_forward_imsg(env->sc_ps, &imsg, PROC_HCE, -1);
390 			proc_forward_imsg(env->sc_ps, &imsg, PROC_RELAY, -1);
391 
392 			memcpy(imsg.data, &verbose, sizeof(verbose));
393 			control_imsg_forward(ps, &imsg);
394 			log_setverbose(verbose);
395 			break;
396 		default:
397 			log_debug("%s: error handling imsg %d",
398 			    __func__, imsg.hdr.type);
399 			break;
400 		}
401 		imsg_free(&imsg);
402 	}
403 
404 	imsg_event_add(&c->iev);
405 }
406 
407 void
408 control_imsg_forward(struct privsep *ps, struct imsg *imsg)
409 {
410 	struct ctl_conn *c;
411 
412 	TAILQ_FOREACH(c, &ctl_conns, entry)
413 		if (c->flags & CTL_CONN_NOTIFY)
414 			imsg_compose_event(&c->iev, imsg->hdr.type,
415 			    0, ps->ps_instance + 1, -1, imsg->data,
416 			    imsg->hdr.len - IMSG_HEADER_SIZE);
417 }