1 /*	$OpenBSD: control.c,v 1.8 2021/03/02 04:10:07 jsg 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 "config.h"
20 
21 #include <sys/stat.h>
22 #include <sys/socket.h>
23 #include <sys/un.h>
24 
25 #include <netinet/in.h>
26 #include <net/if.h>
27 
28 #include <errno.h>
29 #include <limits.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34 
35 #include "amused.h"
36 #include "log.h"
37 #include "control.h"
38 #include "playlist.h"
39 
40 #define	CONTROL_BACKLOG	5
41 
42 struct {
43 	struct event	ev;
44 	struct event	evt;
45 	int		fd;
46 	struct playlist	play;
47 	int		tx;
48 } control_state = {.fd = -1, .tx = -1};
49 
50 struct ctl_conn {
51 	TAILQ_ENTRY(ctl_conn)	entry;
52 	int			monitor; /* 1 if client is in monitor mode */
53 	struct imsgev		iev;
54 };
55 
56 TAILQ_HEAD(ctl_conns, ctl_conn)	ctl_conns = TAILQ_HEAD_INITIALIZER(ctl_conns);
57 
58 struct ctl_conn	*control_connbyfd(int);
59 struct ctl_conn	*control_connbypid(pid_t);
60 void		 control_close(int);
61 
62 int
63 control_init(char *path)
64 {
65 	struct sockaddr_un	 sun;
66 	int			 fd;
67 	mode_t			 old_umask;
68 
69 	if ((fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
70 	    0)) == -1) {
71 		log_warn("%s: socket", __func__);
72 		return (-1);
73 	}
74 
75 	memset(&sun, 0, sizeof(sun));
76 	sun.sun_family = AF_UNIX;
77 	strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
78 
79 	if (unlink(path) == -1)
80 		if (errno != ENOENT) {
81 			log_warn("%s: unlink %s", __func__, path);
82 			close(fd);
83 			return (-1);
84 		}
85 
86 	old_umask = umask(S_IXUSR|S_IXGRP|S_IWOTH|S_IROTH|S_IXOTH);
87 	if (bind(fd, (struct sockaddr *)&sun, sizeof(sun)) == -1) {
88 		log_warn("%s: bind: %s", __func__, path);
89 		close(fd);
90 		umask(old_umask);
91 		return (-1);
92 	}
93 	umask(old_umask);
94 
95 	if (chmod(path, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP) == -1) {
96 		log_warn("%s: chmod", __func__);
97 		close(fd);
98 		(void)unlink(path);
99 		return (-1);
100 	}
101 
102 	return (fd);
103 }
104 
105 int
106 control_listen(int fd)
107 {
108 	if (control_state.fd != -1)
109 		fatalx("%s: received unexpected controlsock", __func__);
110 
111 	control_state.fd = fd;
112 	if (listen(control_state.fd, CONTROL_BACKLOG) == -1) {
113 		log_warn("%s: listen", __func__);
114 		return (-1);
115 	}
116 
117 	event_set(&control_state.ev, control_state.fd, EV_READ,
118 	    control_accept, NULL);
119 	event_add(&control_state.ev, NULL);
120 	evtimer_set(&control_state.evt, control_accept, NULL);
121 
122 	return (0);
123 }
124 
125 void
126 control_accept(int listenfd, short event, void *bula)
127 {
128 	int			 connfd;
129 	socklen_t		 len;
130 	struct sockaddr_un	 sun;
131 	struct ctl_conn		*c;
132 
133 	event_add(&control_state.ev, NULL);
134 	if ((event & EV_TIMEOUT))
135 		return;
136 
137 	len = sizeof(sun);
138 	if ((connfd = accept4(listenfd, (struct sockaddr *)&sun, &len,
139 	    SOCK_CLOEXEC | SOCK_NONBLOCK)) == -1) {
140 		/*
141 		 * Pause accept if we are out of file descriptors, or
142 		 * libevent will haunt us here too.
143 		 */
144 		if (errno == ENFILE || errno == EMFILE) {
145 			struct timeval evtpause = { 1, 0 };
146 
147 			event_del(&control_state.ev);
148 			evtimer_add(&control_state.evt, &evtpause);
149 		} else if (errno != EWOULDBLOCK && errno != EINTR &&
150 		    errno != ECONNABORTED)
151 			log_warn("%s: accept4", __func__);
152 		return;
153 	}
154 
155 	if ((c = calloc(1, sizeof(struct ctl_conn))) == NULL) {
156 		log_warn("%s: calloc", __func__);
157 		close(connfd);
158 		return;
159 	}
160 
161 	imsg_init(&c->iev.ibuf, connfd);
162 	c->iev.handler = control_dispatch_imsg;
163 	c->iev.events = EV_READ;
164 	event_set(&c->iev.ev, c->iev.ibuf.fd, c->iev.events,
165 	    c->iev.handler, &c->iev);
166 	event_add(&c->iev.ev, NULL);
167 
168 	TAILQ_INSERT_TAIL(&ctl_conns, c, entry);
169 }
170 
171 struct ctl_conn *
172 control_connbyfd(int fd)
173 {
174 	struct ctl_conn	*c;
175 
176 	TAILQ_FOREACH(c, &ctl_conns, entry) {
177 		if (c->iev.ibuf.fd == fd)
178 			break;
179 	}
180 
181 	return (c);
182 }
183 
184 struct ctl_conn *
185 control_connbypid(pid_t pid)
186 {
187 	struct ctl_conn	*c;
188 
189 	TAILQ_FOREACH(c, &ctl_conns, entry) {
190 		if (c->iev.ibuf.pid == pid)
191 			break;
192 	}
193 
194 	return (c);
195 }
196 
197 void
198 control_close(int fd)
199 {
200 	struct ctl_conn	*c;
201 
202 	if ((c = control_connbyfd(fd)) == NULL) {
203 		log_warnx("%s: fd %d: not found", __func__, fd);
204 		return;
205 	}
206 
207 	/* abort the transaction if running by this user */
208 	if (control_state.tx != -1 && c->iev.ibuf.fd == control_state.tx) {
209 		playlist_free(&control_state.play);
210 		control_state.tx = -1;
211 	}
212 
213 	msgbuf_clear(&c->iev.ibuf.w);
214 	TAILQ_REMOVE(&ctl_conns, c, entry);
215 
216 	event_del(&c->iev.ev);
217 	close(c->iev.ibuf.fd);
218 
219 	/* Some file descriptors are available again. */
220 	if (evtimer_pending(&control_state.evt, NULL)) {
221 		evtimer_del(&control_state.evt);
222 		event_add(&control_state.ev, NULL);
223 	}
224 
225 	free(c);
226 }
227 
228 void
229 control_notify(struct imsgev *iev, int type)
230 {
231 	struct ctl_conn *c;
232 
233 	TAILQ_FOREACH(c, &ctl_conns, entry) {
234 		if (&c->iev == iev || !c->monitor)
235 			continue;
236 
237 		imsg_compose_event(&c->iev, IMSG_CTL_MONITOR, 0, 0,
238 		    -1, &type, sizeof(type));
239 	}
240 }
241 
242 void
243 control_dispatch_imsg(int fd, short event, void *bula)
244 {
245 	struct ctl_conn		*c;
246 	struct imsg		 imsg;
247 	struct player_repeat	 rp;
248 	ssize_t		 	 n, off;
249 
250 	if ((c = control_connbyfd(fd)) == NULL) {
251 		log_warnx("%s: fd %d: not found", __func__, fd);
252 		return;
253 	}
254 
255 	if (event & EV_READ) {
256 		if (((n = imsg_read(&c->iev.ibuf)) == -1 && errno != EAGAIN) ||
257 		    n == 0) {
258 			control_close(fd);
259 			return;
260 		}
261 	}
262 	if (event & EV_WRITE) {
263 		if (msgbuf_write(&c->iev.ibuf.w) <= 0 && errno != EAGAIN) {
264 			control_close(fd);
265 			return;
266 		}
267 	}
268 
269 	for (;;) {
270 		if ((n = imsg_get(&c->iev.ibuf, &imsg)) == -1) {
271 			control_close(fd);
272 			return;
273 		}
274 		if (n == 0)
275 			break;
276 
277 		switch (imsg.hdr.type) {
278 		case IMSG_CTL_PLAY:
279 			switch (play_state) {
280 			case STATE_STOPPED:
281 				main_playlist_resume();
282 				break;
283 			case STATE_PLAYING:
284 				/* do nothing */
285 				break;
286 			case STATE_PAUSED:
287 				play_state = STATE_PLAYING;
288 				main_send_player(IMSG_RESUME, -1, NULL ,0);
289 				break;
290 			}
291 			control_notify(&c->iev, imsg.hdr.type);
292 			break;
293 		case IMSG_CTL_TOGGLE_PLAY:
294 			switch (play_state) {
295 			case STATE_STOPPED:
296 				main_playlist_resume();
297 				break;
298 			case STATE_PLAYING:
299 				play_state = STATE_PAUSED;
300 				main_send_player(IMSG_PAUSE, -1, NULL, 0);
301 				break;
302 			case STATE_PAUSED:
303 				play_state = STATE_PLAYING;
304 				main_send_player(IMSG_RESUME, -1, NULL, 0);
305 				break;
306 			}
307 			control_notify(&c->iev, imsg.hdr.type);
308 			break;
309 		case IMSG_CTL_PAUSE:
310 			if (play_state != STATE_PLAYING)
311 				break;
312 			play_state = STATE_PAUSED;
313 			main_send_player(IMSG_PAUSE, -1, NULL, 0);
314 			control_notify(&c->iev, imsg.hdr.type);
315 			break;
316 		case IMSG_CTL_STOP:
317 			if (play_state == STATE_STOPPED)
318 				break;
319 			play_state = STATE_STOPPED;
320 			main_send_player(IMSG_STOP, -1, NULL, 0);
321 			control_notify(&c->iev, imsg.hdr.type);
322 			break;
323 		case IMSG_CTL_RESTART:
324 			main_send_player(IMSG_STOP, -1, NULL, 0);
325 			main_restart_track();
326 			control_notify(&c->iev, imsg.hdr.type);
327 			break;
328 		case IMSG_CTL_FLUSH:
329 			playlist_truncate();
330 			control_notify(&c->iev, imsg.hdr.type);
331 			break;
332 		case IMSG_CTL_SHOW:
333 			main_send_playlist(&c->iev);
334 			break;
335 		case IMSG_CTL_STATUS:
336 			main_send_status(&c->iev);
337 			break;
338 		case IMSG_CTL_NEXT:
339 			main_send_player(IMSG_STOP, -1, NULL, 0);
340 			main_playlist_advance();
341 			control_notify(&c->iev, imsg.hdr.type);
342 			break;
343 		case IMSG_CTL_PREV:
344 			main_send_player(IMSG_STOP, -1, NULL, 0);
345 			main_playlist_previous();
346 			control_notify(&c->iev, imsg.hdr.type);
347 			break;
348 		case IMSG_CTL_JUMP:
349 			main_playlist_jump(&c->iev, &imsg);
350 			control_notify(&c->iev, imsg.hdr.type);
351 			break;
352 		case IMSG_CTL_REPEAT:
353 			if (IMSG_DATA_SIZE(imsg) != sizeof(rp)) {
354 				log_warnx("%s: got wrong size", __func__);
355 				break;
356 			}
357 			memcpy(&rp, imsg.data, sizeof(rp));
358 			if (rp.repeat_all != -1)
359 				repeat_all = rp.repeat_all;
360 			if (rp.repeat_one != -1)
361 				repeat_one = rp.repeat_one;
362 			control_notify(&c->iev, imsg.hdr.type);
363 			break;
364 		case IMSG_CTL_BEGIN:
365 			if (control_state.tx != -1) {
366 				main_senderr(&c->iev, "locked");
367 				break;
368 			}
369 			control_state.tx = c->iev.ibuf.fd;
370 			imsg_compose_event(&c->iev, IMSG_CTL_BEGIN, 0, 0, -1,
371 			    NULL, 0);
372 			break;
373 		case IMSG_CTL_ADD:
374 			if (control_state.tx != -1 &&
375 			    control_state.tx != c->iev.ibuf.fd) {
376 				main_senderr(&c->iev, "locked");
377 				break;
378 			}
379 			main_enqueue(control_state.tx != -1,
380 			   &control_state.play,&c->iev, &imsg);
381 			if (control_state.tx == -1)
382 				control_notify(&c->iev, imsg.hdr.type);
383 			break;
384 		case IMSG_CTL_COMMIT:
385 			if (control_state.tx != c->iev.ibuf.fd) {
386 				main_senderr(&c->iev, "locked");
387 				break;
388 			}
389 			if (IMSG_DATA_SIZE(imsg) != sizeof(off)) {
390 				main_senderr(&c->iev, "wrong size");
391 				break;
392 			}
393 			memcpy(&off, imsg.data, sizeof(off));
394 			playlist_swap(&control_state.play, off);
395 			memset(&control_state.play, 0,
396 			    sizeof(control_state.play));
397 			control_state.tx = -1;
398 			imsg_compose_event(&c->iev, IMSG_CTL_COMMIT, 0, 0, -1,
399 			    NULL, 0);
400 			control_notify(&c->iev, imsg.hdr.type);
401 			break;
402 		case IMSG_CTL_MONITOR:
403 			c->monitor = 1;
404 			break;
405 		case IMSG_CTL_SEEK:
406 			if (IMSG_DATA_SIZE(imsg) !=
407 			    sizeof(struct player_seek)) {
408 				main_senderr(&c->iev, "wrong size");
409 				break;
410 			}
411 			switch (play_state) {
412 			case STATE_STOPPED:
413 				main_playlist_resume();
414 				break;
415 			case STATE_PLAYING:
416 				break;
417 			case STATE_PAUSED:
418 				play_state = STATE_PLAYING;
419 				break;
420 			}
421 			main_send_player(IMSG_CTL_SEEK, -1, imsg.data,
422 			    IMSG_DATA_SIZE(imsg));
423 			control_notify(&c->iev, imsg.hdr.type);
424 			break;
425 		default:
426 			log_debug("%s: error handling imsg %d", __func__,
427 			    imsg.hdr.type);
428 			break;
429 		}
430 		imsg_free(&imsg);
431 	}
432 
433 	imsg_event_add(&c->iev);
434 }
435 
436 int
437 control_imsg_relay(struct imsg *imsg)
438 {
439 	struct ctl_conn	*c;
440 
441 	if ((c = control_connbypid(imsg->hdr.pid)) == NULL)
442 		return (0);
443 
444 	return (imsg_compose_event(&c->iev, imsg->hdr.type, 0, imsg->hdr.pid,
445 	    -1, imsg->data, IMSG_DATA_SIZE(*imsg)));
446 }