1 /*	$OpenBSD: control.c,v 1.8 2021/03/02 04:10:07 jsg Exp $	*/
2 
3 /*
4  * Copyright (c) 2022, 2023 Omar Polo <op@omarpolo.com>
5  * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
6  *
7  * Permission to use, copy, modify, and distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  */
19 
20 #include "config.h"
21 
22 #include <sys/stat.h>
23 #include <sys/socket.h>
24 #include <sys/un.h>
25 
26 #include <netinet/in.h>
27 #include <net/if.h>
28 
29 #include <errno.h>
30 #include <fcntl.h>
31 #include <limits.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <unistd.h>
36 
37 #include "amused.h"
38 #include "ev.h"
39 #include "log.h"
40 #include "control.h"
41 #include "playlist.h"
42 
43 #define	CONTROL_BACKLOG	5
44 
45 struct {
46 	int		fd;
47 	unsigned int	tout;
48 	struct playlist	play;
49 	int		tx;
50 } control_state = {.fd = -1, .tx = -1};
51 
52 struct ctl_conn {
53 	TAILQ_ENTRY(ctl_conn)	entry;
54 	int			monitor; /* 1 if client is in monitor mode */
55 	struct imsgev		iev;
56 };
57 
58 TAILQ_HEAD(ctl_conns, ctl_conn)	ctl_conns = TAILQ_HEAD_INITIALIZER(ctl_conns);
59 
60 struct ctl_conn	*control_connbyfd(int);
61 struct ctl_conn	*control_connbypid(pid_t);
62 void		 control_close(int);
63 
64 int
65 control_init(char *path)
66 {
67 	struct sockaddr_un	 sun;
68 	int			 fd, flags;
69 	mode_t			 old_umask;
70 
71 	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
72 		log_warn("%s: socket", __func__);
73 		return (-1);
74 	}
75 
76 	if ((flags = fcntl(fd, F_GETFL)) == -1 ||
77 	    fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
78 		fatal("fcntl(O_NONBLOCK)");
79 
80 	if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
81 		fatal("fcntl(CLOEXEC)");
82 
83 	memset(&sun, 0, sizeof(sun));
84 	sun.sun_family = AF_UNIX;
85 	strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
86 
87 	if (unlink(path) == -1)
88 		if (errno != ENOENT) {
89 			log_warn("%s: unlink %s", __func__, path);
90 			close(fd);
91 			return (-1);
92 		}
93 
94 	old_umask = umask(S_IXUSR|S_IXGRP|S_IWOTH|S_IROTH|S_IXOTH);
95 	if (bind(fd, (struct sockaddr *)&sun, sizeof(sun)) == -1) {
96 		log_warn("%s: bind: %s", __func__, path);
97 		close(fd);
98 		umask(old_umask);
99 		return (-1);
100 	}
101 	umask(old_umask);
102 
103 	if (chmod(path, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP) == -1) {
104 		log_warn("%s: chmod", __func__);
105 		close(fd);
106 		(void)unlink(path);
107 		return (-1);
108 	}
109 
110 	return (fd);
111 }
112 
113 static void
114 enable_accept(int fd, int ev, void *bula)
115 {
116 	control_state.tout = 0;
117 	ev_add(control_state.fd, EV_READ, control_accept, NULL);
118 }
119 
120 int
121 control_listen(int fd)
122 {
123 	if (control_state.fd != -1)
124 		fatalx("%s: received unexpected controlsock", __func__);
125 
126 	control_state.fd = fd;
127 	if (listen(control_state.fd, CONTROL_BACKLOG) == -1) {
128 		log_warn("%s: listen", __func__);
129 		return (-1);
130 	}
131 
132 	enable_accept(-1, 0, NULL);
133 	return (0);
134 }
135 
136 void
137 control_accept(int listenfd, int event, void *bula)
138 {
139 	int			 connfd, flags;
140 	socklen_t		 len;
141 	struct sockaddr_un	 sun;
142 	struct ctl_conn		*c;
143 
144 	len = sizeof(sun);
145 	if ((connfd = accept(listenfd, (struct sockaddr *)&sun, &len)) == -1) {
146 		/*
147 		 * Pause accept if we are out of file descriptors, or
148 		 * libevent will haunt us here too.
149 		 */
150 		if (errno == ENFILE || errno == EMFILE) {
151 			struct timeval evtpause = { 1, 0 };
152 
153 			ev_del(control_state.fd);
154 			control_state.tout = ev_timer(&evtpause, enable_accept, NULL);
155 			if (control_state.tout == 0)
156 				fatal("ev_timer failed");
157 		} else if (errno != EWOULDBLOCK && errno != EINTR &&
158 		    errno != ECONNABORTED)
159 			log_warn("%s: accept4", __func__);
160 		return;
161 	}
162 
163 	if ((flags = fcntl(connfd, F_GETFL)) == -1 ||
164 	    fcntl(connfd, F_SETFL, flags | O_NONBLOCK) == -1)
165 		fatal("fcntl(O_NONBLOCK)");
166 	if (fcntl(connfd, F_SETFD, FD_CLOEXEC) == -1)
167 		fatal("fcntl(CLOEXEC)");
168 
169 	if ((c = calloc(1, sizeof(struct ctl_conn))) == NULL) {
170 		log_warn("%s: calloc", __func__);
171 		close(connfd);
172 		return;
173 	}
174 
175 	imsg_init(&c->iev.imsgbuf, connfd);
176 	c->iev.handler = control_dispatch_imsg;
177 	c->iev.events = EV_READ;
178 	ev_add(c->iev.imsgbuf.fd, c->iev.events, c->iev.handler, &c->iev);
179 
180 	TAILQ_INSERT_TAIL(&ctl_conns, c, entry);
181 }
182 
183 struct ctl_conn *
184 control_connbyfd(int fd)
185 {
186 	struct ctl_conn	*c;
187 
188 	TAILQ_FOREACH(c, &ctl_conns, entry) {
189 		if (c->iev.imsgbuf.fd == fd)
190 			break;
191 	}
192 
193 	return (c);
194 }
195 
196 struct ctl_conn *
197 control_connbypid(pid_t pid)
198 {
199 	struct ctl_conn	*c;
200 
201 	TAILQ_FOREACH(c, &ctl_conns, entry) {
202 		if (c->iev.imsgbuf.pid == pid)
203 			break;
204 	}
205 
206 	return (c);
207 }
208 
209 void
210 control_close(int fd)
211 {
212 	struct ctl_conn	*c;
213 
214 	if ((c = control_connbyfd(fd)) == NULL) {
215 		log_warnx("%s: fd %d: not found", __func__, fd);
216 		return;
217 	}
218 
219 	/* abort the transaction if running by this user */
220 	if (control_state.tx != -1 && c->iev.imsgbuf.fd == control_state.tx) {
221 		playlist_free(&control_state.play);
222 		control_state.tx = -1;
223 	}
224 
225 	msgbuf_clear(&c->iev.imsgbuf.w);
226 	TAILQ_REMOVE(&ctl_conns, c, entry);
227 
228 	ev_del(c->iev.imsgbuf.fd);
229 	close(c->iev.imsgbuf.fd);
230 
231 	/* Some file descriptors are available again. */
232 	if (ev_timer_pending(control_state.tout)) {
233 		ev_timer(NULL, NULL, NULL);
234 		ev_add(control_state.fd, EV_READ, control_accept, NULL);
235 	}
236 
237 	free(c);
238 }
239 
240 void
241 control_notify(int type)
242 {
243 	struct ctl_conn *c;
244 	struct player_event ev;
245 
246 	memset(&ev, 0, sizeof(ev));
247 	ev.event = type;
248 	ev.position = current_position;
249 	ev.duration = current_duration;
250 	ev.mode.repeat_one = repeat_one;
251 	ev.mode.repeat_all = repeat_all;
252 	ev.mode.consume = consume;
253 
254 	TAILQ_FOREACH(c, &ctl_conns, entry) {
255 		if (!c->monitor)
256 			continue;
257 
258 		imsg_compose_event(&c->iev, IMSG_CTL_MONITOR, 0, 0,
259 		    -1, &ev, sizeof(ev));
260 	}
261 }
262 
263 static int
264 new_mode(int val, int newval)
265 {
266 	if (newval == MODE_UNDEF)
267 		return val;
268 	if (newval == MODE_TOGGLE)
269 		return !val;
270 	return !!newval;
271 }
272 
273 void
274 control_dispatch_imsg(int fd, int event, void *bula)
275 {
276 	struct ctl_conn		*c;
277 	struct imsgbuf		*imsgbuf;
278 	struct imsg		 imsg;
279 	struct player_mode	 mode;
280 	struct player_seek	 seek;
281 	ssize_t		 	 n, off;
282 	int			 type;
283 
284 	if ((c = control_connbyfd(fd)) == NULL) {
285 		log_warnx("%s: fd %d: not found", __func__, fd);
286 		return;
287 	}
288 
289 	imsgbuf = &c->iev.imsgbuf;
290 
291 	if (event & EV_READ) {
292 		if (((n = imsg_read(imsgbuf)) == -1 && errno != EAGAIN) ||
293 		    n == 0) {
294 			control_close(fd);
295 			return;
296 		}
297 	}
298 	if (event & EV_WRITE) {
299 		if (msgbuf_write(&imsgbuf->w) <= 0 && errno != EAGAIN) {
300 			control_close(fd);
301 			return;
302 		}
303 	}
304 
305 	for (;;) {
306 		if ((n = imsg_get(imsgbuf, &imsg)) == -1) {
307 			control_close(fd);
308 			return;
309 		}
310 		if (n == 0)
311 			break;
312 
313 		switch (type = imsg_get_type(&imsg)) {
314 		case IMSG_CTL_PLAY:
315 			switch (play_state) {
316 			case STATE_STOPPED:
317 				main_playlist_resume();
318 				break;
319 			case STATE_PLAYING:
320 				/* do nothing */
321 				break;
322 			case STATE_PAUSED:
323 				play_state = STATE_PLAYING;
324 				main_send_player(IMSG_RESUME, -1, NULL ,0);
325 				break;
326 			}
327 			control_notify(type);
328 			break;
329 		case IMSG_CTL_TOGGLE_PLAY:
330 			switch (play_state) {
331 			case STATE_STOPPED:
332 				control_notify(IMSG_CTL_PLAY);
333 				main_playlist_resume();
334 				break;
335 			case STATE_PLAYING:
336 				control_notify(IMSG_CTL_PAUSE);
337 				play_state = STATE_PAUSED;
338 				main_send_player(IMSG_PAUSE, -1, NULL, 0);
339 				break;
340 			case STATE_PAUSED:
341 				control_notify(IMSG_CTL_PLAY);
342 				play_state = STATE_PLAYING;
343 				main_send_player(IMSG_RESUME, -1, NULL, 0);
344 				break;
345 			}
346 			break;
347 		case IMSG_CTL_PAUSE:
348 			if (play_state != STATE_PLAYING)
349 				break;
350 			play_state = STATE_PAUSED;
351 			main_send_player(IMSG_PAUSE, -1, NULL, 0);
352 			control_notify(type);
353 			break;
354 		case IMSG_CTL_STOP:
355 			if (play_state == STATE_STOPPED)
356 				break;
357 			play_state = STATE_STOPPED;
358 			main_send_player(IMSG_STOP, -1, NULL, 0);
359 			control_notify(type);
360 			break;
361 		case IMSG_CTL_FLUSH:
362 			playlist_truncate();
363 			control_notify(IMSG_CTL_COMMIT);
364 			break;
365 		case IMSG_CTL_SHOW:
366 			main_send_playlist(&c->iev);
367 			break;
368 		case IMSG_CTL_STATUS:
369 			main_send_status(&c->iev);
370 			break;
371 		case IMSG_CTL_NEXT:
372 			control_notify(type);
373 			main_send_player(IMSG_STOP, -1, NULL, 0);
374 			main_playlist_advance();
375 			break;
376 		case IMSG_CTL_PREV:
377 			control_notify(type);
378 			main_send_player(IMSG_STOP, -1, NULL, 0);
379 			main_playlist_previous();
380 			break;
381 		case IMSG_CTL_JUMP:
382 			main_playlist_jump(&c->iev, &imsg);
383 			break;
384 		case IMSG_CTL_MODE:
385 			if (imsg_get_data(&imsg, &mode, sizeof(mode)) == -1) {
386 				log_warnx("%s: got wrong size", __func__);
387 				break;
388 			}
389 			consume = new_mode(consume, mode.consume);
390 			repeat_all = new_mode(repeat_all, mode.repeat_all);
391 			repeat_one = new_mode(repeat_one, mode.repeat_one);
392 			control_notify(type);
393 			break;
394 		case IMSG_CTL_BEGIN:
395 			if (control_state.tx != -1) {
396 				main_senderr(&c->iev, "locked");
397 				break;
398 			}
399 			control_state.tx = imsgbuf->fd;
400 			imsg_compose_event(&c->iev, IMSG_CTL_BEGIN, 0, 0, -1,
401 			    NULL, 0);
402 			break;
403 		case IMSG_CTL_ADD:
404 			if (control_state.tx != -1 &&
405 			    control_state.tx != imsgbuf->fd) {
406 				main_senderr(&c->iev, "locked");
407 				break;
408 			}
409 			main_enqueue(control_state.tx != -1,
410 			   &control_state.play,&c->iev, &imsg);
411 			if (control_state.tx == -1)
412 				control_notify(type);
413 			break;
414 		case IMSG_CTL_COMMIT:
415 			if (control_state.tx != imsgbuf->fd) {
416 				main_senderr(&c->iev, "locked");
417 				break;
418 			}
419 			if (imsg_get_data(&imsg, &off, sizeof(off)) == -1) {
420 				main_senderr(&c->iev, "wrong size");
421 				break;
422 			}
423 			playlist_swap(&control_state.play, off);
424 			memset(&control_state.play, 0,
425 			    sizeof(control_state.play));
426 			control_state.tx = -1;
427 			imsg_compose_event(&c->iev, IMSG_CTL_COMMIT, 0, 0, -1,
428 			    NULL, 0);
429 			control_notify(type);
430 			break;
431 		case IMSG_CTL_MONITOR:
432 			c->monitor = 1;
433 			break;
434 		case IMSG_CTL_SEEK:
435 			if (imsg_get_data(&imsg, &seek, sizeof(seek)) == -1) {
436 				main_senderr(&c->iev, "wrong size");
437 				break;
438 			}
439 			main_seek(&seek);
440 			break;
441 		default:
442 			log_debug("%s: error handling imsg %d", __func__,
443 			    type);
444 			break;
445 		}
446 		imsg_free(&imsg);
447 	}
448 
449 	imsg_event_add(&c->iev);
450 }