1 /*
2  * Copyright (c) 2022, 2023 Omar Polo <op@omarpolo.com>
3  * Copyright (c) 2015 Theo de Raadt <deraadt@openbsd.org>
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 #include "config.h"
19 
20 #include <sys/socket.h>
21 #include <sys/un.h>
22 
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <limits.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <stdint.h>
29 #include <string.h>
30 #include <syslog.h>
31 #include <time.h>
32 #include <unistd.h>
33 
34 #include "amused.h"
35 #include "log.h"
36 #include "playlist.h"
37 #include "xmalloc.h"
38 
39 static struct imsgbuf	*imsgbuf;
40 char			 cwd[PATH_MAX];
41 
42 static int	ctl_noarg(struct parse_result *, int, char **);
43 static int	ctl_add(struct parse_result *, int, char **);
44 static int	ctl_show(struct parse_result *, int, char **);
45 static int	ctl_load(struct parse_result *, int, char **);
46 static int	ctl_jump(struct parse_result *, int, char **);
47 static int	ctl_repeat(struct parse_result *, int, char **);
48 static int	ctl_consume(struct parse_result *, int, char **);
49 static int	ctl_monitor(struct parse_result *, int, char **);
50 static int	ctl_seek(struct parse_result *, int, char **);
51 static int	ctl_status(struct parse_result *, int, char **);
52 
53 struct ctl_command ctl_commands[] = {
54 	{ "add",	ADD,		ctl_add,	"files..."},
55 	{ "consume",	MODE,		ctl_consume,	"one|all"},
56 	{ "flush",	FLUSH,		ctl_noarg,	""},
57 	{ "jump",	JUMP,		ctl_jump,	"pattern"},
58 	{ "load",	LOAD,		ctl_load,	"[file]"},
59 	{ "monitor",	MONITOR,	ctl_monitor,	"[events]"},
60 	{ "next",	NEXT,		ctl_noarg,	""},
61 	{ "pause",	PAUSE,		ctl_noarg,	""},
62 	{ "play",	PLAY,		ctl_noarg,	""},
63 	{ "prev",	PREV,		ctl_noarg,	""},
64 	{ "repeat",	MODE,		ctl_repeat,	"one|all on|off"},
65 	{ "restart",	RESTART,	ctl_noarg,	""},
66 	{ "seek",	SEEK,		ctl_seek,	"[+-]time[%]"},
67 	{ "show",	SHOW,		ctl_show,	"[-p]"},
68 	{ "status",	STATUS,		ctl_status,	"[-f fmt]"},
69 	{ "stop",	STOP,		ctl_noarg,	""},
70 	{ "toggle",	TOGGLE,		ctl_noarg,	""},
71 	{ NULL, 0, NULL, NULL},
72 };
73 
74 __dead void
75 usage(void)
76 {
77 	fprintf(stderr, "usage: %s [-dv] [-s socket]\n", getprogname());
78 	exit(1);
79 }
80 
81 static __dead void
82 ctl_usage(struct ctl_command *ctl)
83 {
84 	fprintf(stderr, "usage: %s [-v] [-s socket] %s %s\n", getprogname(),
85 	    ctl->name, ctl->usage);
86 	exit(1);
87 }
88 
89 /* based on canonpath from kern_pledge.c */
90 static int
91 canonpath(const char *input, char *buf, size_t bufsize)
92 {
93 	const char *p;
94 	char *q, path[PATH_MAX];
95 	int r;
96 
97 	if (input[0] != '/') {
98 		r = snprintf(path, sizeof(path), "%s/%s", cwd, input);
99 		if (r < 0 || (size_t)r >= sizeof(path)) {
100 			errno = ENAMETOOLONG;
101 			return -1;
102 		}
103 		input = path;
104 	}
105 
106 	p = input;
107 	q = buf;
108 	while (*p && (q - buf < bufsize)) {
109 		if (p[0] == '/' && (p[1] == '/' || p[1] == '\0')) {
110 			p += 1;
111 
112 		} else if (p[0] == '/' && p[1] == '.' &&
113 		    (p[2] == '/' || p[2] == '\0')) {
114 			p += 2;
115 
116 		} else if (p[0] == '/' && p[1] == '.' && p[2] == '.' &&
117 		    (p[3] == '/' || p[3] == '\0')) {
118 			p += 3;
119 			if (q != buf)	/* "/../" at start of buf */
120 				while (*--q != '/')
121 					continue;
122 
123 		} else {
124 			*q++ = *p++;
125 		}
126 	}
127 	if ((*p == '\0') && (q - buf < bufsize)) {
128 		*q = 0;
129 		return 0;
130 	} else {
131 		errno = ENAMETOOLONG;
132 		return -1;
133 	}
134 }
135 
136 static int
137 parse(struct parse_result *res, int argc, char **argv)
138 {
139 	struct ctl_command	*ctl = NULL;
140 	const char		*argv0;
141 	int			 i, status;
142 
143 	if ((argv0 = argv[0]) == NULL)
144 		argv0 = "status";
145 
146 	for (i = 0; ctl_commands[i].name != NULL; ++i) {
147 		if (strncmp(ctl_commands[i].name, argv0, strlen(argv0))
148 		    == 0) {
149 			if (ctl != NULL) {
150 				fprintf(stderr,
151 				    "ambiguous argument: %s\n", argv0);
152 				usage();
153 			}
154 			ctl = &ctl_commands[i];
155 		}
156 	}
157 
158 	if (ctl == NULL) {
159 		fprintf(stderr, "unknown argument: %s\n", argv[0]);
160 		usage();
161 	}
162 
163 	res->action = ctl->action;
164 	res->ctl = ctl;
165 
166 	status = ctl->main(res, argc, argv);
167 	close(imsgbuf->fd);
168 	free(imsgbuf);
169 	return status;
170 }
171 
172 static int
173 load_files(struct parse_result *res, int *ret)
174 {
175 	const char	*file;
176 	char		*line = NULL;
177 	char		 path[PATH_MAX];
178 	size_t		 linesize = 0, i = 0;
179 	ssize_t		 linelen, curr = -1;
180 
181 	while ((linelen = getline(&line, &linesize, res->fp)) != -1) {
182 		if (linelen == 0)
183 			continue;
184 		line[linelen-1] = '\0';
185 		file = line;
186 		if (!strncmp(file, "> ", 2)) {
187 			file += 2;
188 			curr = i;
189 		} else if (!strncmp(file, "  ", 2))
190 			file += 2;
191 
192 		memset(path, 0, sizeof(path));
193 		if (canonpath(file, path, sizeof(path)) == -1) {
194 			log_warn("canonpath %s", file);
195 			continue;
196 		}
197 
198 		i++;
199 		imsg_compose(imsgbuf, IMSG_CTL_ADD, 0, 0, -1,
200 		    path, sizeof(path));
201 	}
202 
203 	free(line);
204 	if (ferror(res->fp))
205 		fatal("getline");
206 	fclose(res->fp);
207 	res->fp = NULL;
208 
209 	imsg_compose(imsgbuf, IMSG_CTL_COMMIT, 0, 0, -1,
210 	    &curr, sizeof(curr));
211 	imsg_flush(imsgbuf);
212 	return 0;
213 }
214 
215 static const char *
216 imsg_strerror(struct imsg *imsg)
217 {
218 	struct ibuf ibuf;
219 	size_t datalen;
220 	const char *msg;
221 
222 	if (imsg_get_ibuf(imsg, &ibuf) == -1 ||
223 	    (datalen = ibuf_size(&ibuf)) == 0 ||
224 	    (msg = ibuf_data(&ibuf)) == NULL ||
225 	    msg[datalen - 1] != '\0')
226 		fatalx("malformed error message");
227 
228 	return msg;
229 }
230 
231 static const char *
232 event_name(int type)
233 {
234 	switch (type) {
235 	case IMSG_CTL_PLAY:
236 		return "play";
237 	case IMSG_CTL_PAUSE:
238 		return "pause";
239 	case IMSG_CTL_STOP:
240 		return "stop";
241 	case IMSG_CTL_NEXT:
242 		return "next";
243 	case IMSG_CTL_PREV:
244 		return "prev";
245 	case IMSG_CTL_JUMP:
246 		return "jump";
247 	case IMSG_CTL_ADD:
248 		return "add";
249 	case IMSG_CTL_COMMIT:
250 		return "load";
251 	case IMSG_CTL_MODE:
252 		return "mode";
253 	case IMSG_CTL_SEEK:
254 		return "seek";
255 	default:
256 		return "unknown";
257 	}
258 }
259 
260 static void
261 print_time(const char *label, int64_t seconds, const char *suffx)
262 {
263 	int hours, minutes;
264 
265 	if (seconds < 0)
266 		seconds = 0;
267 
268 	hours = seconds / 3600;
269 	seconds -= hours * 3600;
270 
271 	minutes = seconds / 60;
272 	seconds -= minutes * 60;
273 
274 	printf("%s", label);
275 	if (hours != 0)
276 		printf("%02d:", hours);
277 	printf("%02d:%02lld%s", minutes, (long long)seconds, suffx);
278 }
279 
280 static void
281 print_status(struct player_status *ps, const char *spec)
282 {
283 	const char *status;
284 	double percent;
285 	char *dup, *tmp, *tok;
286 
287 	if (ps->status == STATE_STOPPED)
288 		status = "stopped";
289 	else if (ps->status == STATE_PLAYING)
290 		status = "playing";
291 	else if (ps->status == STATE_PAUSED)
292 		status = "paused";
293 	else
294 		status = "unknown";
295 
296 	percent = 100.0 * (double)ps->position / (double)ps->duration;
297 
298 	tmp = dup = xstrdup(spec);
299 	while ((tok = strsep(&tmp, ",")) != NULL) {
300 		if (*tok == '\0')
301 			continue;
302 
303 		if (!strcmp(tok, "path")) {
304 			puts(ps->path);
305 		} else if (!strcmp(tok, "mode:oneline")) {
306 			printf("repeat one:%s ",
307 			    ps->mode.repeat_one ? "on" : "off");
308 			printf("all:%s ", ps->mode.repeat_all ? "on" : "off");
309 			printf("consume:%s\n", ps->mode.consume ? "on" : "off");
310 		} else if (!strcmp(tok, "mode")) {
311 			printf("repeat all %s\n",
312 			    ps->mode.repeat_all ? "on" : "off");
313 			printf("repeat one %s\n",
314 			    ps->mode.repeat_one ? "on" : "off");
315 			printf("consume %s\n",
316 			    ps->mode.consume ? "on" : "off");
317 		} else if (!strcmp(tok, "status")) {
318 			printf("%s %s\n", status, ps->path);
319 		} else if (!strcmp(tok, "time:oneline")) {
320 			print_time("time ", ps->position, " / ");
321 			print_time("", ps->duration, "\n");
322 		} else if (!strcmp(tok, "time:percentage")) {
323 			printf("position %.2f%%\n", percent);
324 		} else if (!strcmp(tok, "time:raw")) {
325 			printf("position %lld\n", (long long)ps->position);
326 			printf("duration %lld\n", (long long)ps->duration);
327 		} else if (!strcmp(tok, "time")) {
328 			print_time("position ", ps->position, "\n");
329 			print_time("duration ", ps->duration, "\n");
330 		}
331 	}
332 
333 	free(dup);
334 }
335 
336 static void
337 print_monitor_event(struct player_event *ev)
338 {
339 	switch (ev->event) {
340 	case IMSG_CTL_MODE:
341 		printf("%s repeat one:%s all:%s consume:%s\n",
342 		    event_name(ev->event),
343 		    ev->mode.repeat_one ? "on" : "off",
344 		    ev->mode.repeat_all ? "on" : "off",
345 		    ev->mode.consume ? "on" : "off");
346 		break;
347 	case IMSG_CTL_SEEK:
348 		printf("%s %lld %lld\n", event_name(ev->event),
349 		    (long long)ev->position, (long long)ev->duration);
350 		break;
351 	default:
352 		puts(event_name(ev->event));
353 		break;
354 	}
355 
356 	fflush(stdout);
357 }
358 
359 static int
360 ctlaction(struct parse_result *res)
361 {
362 	char path[PATH_MAX];
363 	struct imsg imsg;
364 	struct player_status ps;
365 	struct player_event ev;
366 	ssize_t n;
367 	int i, type, ret = 0, done = 1;
368 
369 	if (pledge("stdio", NULL) == -1)
370 		fatal("pledge");
371 
372 	switch (res->action) {
373 	case PLAY:
374 		imsg_compose(imsgbuf, IMSG_CTL_PLAY, 0, 0, -1, NULL, 0);
375 		if (verbose) {
376 			imsg_compose(imsgbuf, IMSG_CTL_STATUS, 0, 0, -1,
377 			    NULL, 0);
378 			done = 0;
379 		}
380 		break;
381 	case PAUSE:
382 		imsg_compose(imsgbuf, IMSG_CTL_PAUSE, 0, 0, -1, NULL, 0);
383 		break;
384 	case TOGGLE:
385 		imsg_compose(imsgbuf, IMSG_CTL_TOGGLE_PLAY, 0, 0, -1, NULL, 0);
386 		if (verbose) {
387 			imsg_compose(imsgbuf, IMSG_CTL_STATUS, 0, 0, -1,
388 			    NULL, 0);
389 			done = 0;
390 		}
391 		break;
392 	case STOP:
393 		imsg_compose(imsgbuf, IMSG_CTL_STOP, 0, 0, -1, NULL, 0);
394 		break;
395 	case ADD:
396 		done = 0;
397 		for (i = 0; res->files[i] != NULL; ++i) {
398 			memset(path, 0, sizeof(path));
399 			if (canonpath(res->files[i], path, sizeof(path))
400 			    == -1) {
401 				log_warn("canonpath %s", res->files[i]);
402 				continue;
403 			}
404 
405 			imsg_compose(imsgbuf, IMSG_CTL_ADD, 0, 0, -1,
406 			    path, sizeof(path));
407 		}
408 		ret = i == 0;
409 		break;
410 	case FLUSH:
411 		imsg_compose(imsgbuf, IMSG_CTL_FLUSH, 0, 0, -1, NULL, 0);
412 		break;
413 	case SHOW:
414 		done = 0;
415 		imsg_compose(imsgbuf, IMSG_CTL_SHOW, 0, 0, -1, NULL, 0);
416 		break;
417 	case STATUS:
418 		done = 0;
419 		imsg_compose(imsgbuf, IMSG_CTL_STATUS, 0, 0, -1, NULL, 0);
420 		break;
421 	case NEXT:
422 		imsg_compose(imsgbuf, IMSG_CTL_NEXT, 0, 0, -1, NULL, 0);
423 		if (verbose) {
424 			imsg_compose(imsgbuf, IMSG_CTL_STATUS, 0, 0, -1,
425 			    NULL, 0);
426 			done = 0;
427 		}
428 		break;
429 	case PREV:
430 		imsg_compose(imsgbuf, IMSG_CTL_PREV, 0, 0, -1, NULL, 0);
431 		if (verbose) {
432 			imsg_compose(imsgbuf, IMSG_CTL_STATUS, 0, 0, -1,
433 			    NULL, 0);
434 			done = 0;
435 		}
436 		break;
437 	case LOAD:
438 		done = 0;
439 		imsg_compose(imsgbuf, IMSG_CTL_BEGIN, 0, 0, -1, NULL, 0);
440 		break;
441 	case JUMP:
442 		done = 0;
443 		memset(path, 0, sizeof(path));
444 		strlcpy(path, res->files[0], sizeof(path));
445 		imsg_compose(imsgbuf, IMSG_CTL_JUMP, 0, 0, -1,
446 		    path, sizeof(path));
447 		break;
448 	case MODE:
449 		done = 0;
450 		imsg_compose(imsgbuf, IMSG_CTL_MODE, 0, 0, -1,
451 		    &res->mode, sizeof(res->mode));
452 		imsg_compose(imsgbuf, IMSG_CTL_STATUS, 0, 0, -1,
453 		    &res->mode, sizeof(res->mode));
454 		res->status_format = "mode:oneline";
455 		if (verbose)
456 			res->status_format = "mode";
457 		break;
458 	case MONITOR:
459 		done = 0;
460 		imsg_compose(imsgbuf, IMSG_CTL_MONITOR, 0, 0, -1,
461 		    NULL, 0);
462 		break;
463 	case RESTART:
464 		memset(&res->seek, 0, sizeof(res->seek));
465 		/* fallthrough */
466 	case SEEK:
467 		imsg_compose(imsgbuf, IMSG_CTL_SEEK, 0, 0, -1, &res->seek,
468 		    sizeof(res->seek));
469 		break;
470 	case NONE:
471 		/* action not expected */
472 		fatalx("invalid action %u", res->action);
473 		break;
474 	}
475 
476 	if (ret != 0)
477 		goto end;
478 
479 	imsg_flush(imsgbuf);
480 
481 	i = 0;
482 	while (!done) {
483 		if ((n = imsg_read(imsgbuf)) == -1 && errno != EAGAIN)
484 			fatalx("imsg_read error");
485 		if (n == 0)
486 			fatalx("pipe closed");
487 
488 		while (!done) {
489 			if ((n = imsg_get(imsgbuf, &imsg)) == -1)
490 				fatalx("imsg_get error");
491 			if (n == 0)
492 				break;
493 
494 			type = imsg_get_type(&imsg);
495 			if (type == IMSG_CTL_ERR) {
496 				log_warnx("%s: %s", res->ctl->name,
497 				    imsg_strerror(&imsg));
498 				ret = 1;
499 				done = 1;
500 				break;
501 			}
502 
503 			switch (res->action) {
504 			case ADD:
505 				if (res->files[i] == NULL)
506 					fatalx("received more replies than "
507 					    "files enqueued.");
508 
509 				if (type == IMSG_CTL_ADD)
510 					log_debug("enqueued %s", res->files[i]);
511 				else
512 					fatalx("invalid message %d", type);
513 				i++;
514 				done = res->files[i] == NULL;
515 				break;
516 			case SHOW:
517 				if (imsg_get_len(&imsg) == 0) {
518 					done = 1;
519 					break;
520 				}
521 				if (imsg_get_data(&imsg, &ps, sizeof(ps))
522 				    == -1)
523 					fatalx("data size mismatch");
524 				if (ps.path[sizeof(ps.path) - 1] != '\0')
525 					fatalx("received corrupted data");
526 				if (res->pretty) {
527 					char c = ' ';
528 					if (ps.status == STATE_PLAYING)
529 						c = '>';
530 					printf("%c ", c);
531 				}
532 				puts(ps.path);
533 				break;
534 			case PLAY:
535 			case TOGGLE:
536 			case STATUS:
537 			case NEXT:
538 			case PREV:
539 			case JUMP:
540 			case MODE:
541 				if (type != IMSG_CTL_STATUS)
542 					fatalx("invalid message %d", type);
543 
544 				if (imsg_get_data(&imsg, &ps, sizeof(ps))
545 				    == -1)
546 					fatalx("data size mismatch");
547 				if (ps.path[sizeof(ps.path) - 1] != '\0')
548 					fatalx("received corrupted data");
549 
550 				print_status(&ps, res->status_format);
551 				done = 1;
552 				break;
553 			case LOAD:
554 				if (type == IMSG_CTL_ADD)
555 					break;
556 				if (type == IMSG_CTL_COMMIT) {
557 					done = 1;
558 					break;
559 				}
560 
561 				if (type != IMSG_CTL_BEGIN)
562 					fatalx("invalid message %d", type);
563 
564 				load_files(res, &ret);
565 				break;
566 			case MONITOR:
567 				if (type != IMSG_CTL_MONITOR)
568 					fatalx("invalid message %d", type);
569 
570 				if (imsg_get_data(&imsg, &ev, sizeof(ev))
571 				    == -1)
572 					fatalx("data size mismatch");
573 
574 				if (ev.event < 0 || ev.event > IMSG__LAST)
575 					fatalx("received corrupted data");
576 
577 				if (!res->monitor[ev.event])
578 					break;
579 
580 				print_monitor_event(&ev);
581 				break;
582 			default:
583 				done = 1;
584 				break;
585 			}
586 
587 			imsg_free(&imsg);
588 		}
589 	}
590 
591 end:
592 	return ret;
593 }
594 
595 static int
596 ctl_noarg(struct parse_result *res, int argc, char **argv)
597 {
598 	int ch;
599 
600 	while ((ch = getopt(argc, argv, "")) != -1)
601 		ctl_usage(res->ctl);
602 	argc -= optind;
603 	argv += optind;
604 
605 	if (argc > 0)
606 		ctl_usage(res->ctl);
607 
608 	return ctlaction(res);
609 }
610 
611 static int
612 ctl_add(struct parse_result *res, int argc, char **argv)
613 {
614 	int ch;
615 
616 	while ((ch = getopt(argc, argv, "")) != -1)
617 		ctl_usage(res->ctl);
618 	argc -= optind;
619 	argv += optind;
620 
621 	if (argc == 0)
622 		ctl_usage(res->ctl);
623 	res->files = argv;
624 
625 	return ctlaction(res);
626 }
627 
628 static int
629 ctl_show(struct parse_result *res, int argc, char **argv)
630 {
631 	int ch;
632 
633 	while ((ch = getopt(argc, argv, "p")) != -1) {
634 		switch (ch) {
635 		case 'p':
636 			res->pretty = 1;
637 			break;
638 		default:
639 			ctl_usage(res->ctl);
640 		}
641 	}
642 
643 	return ctlaction(res);
644 }
645 
646 static int
647 ctl_load(struct parse_result *res, int argc, char **argv)
648 {
649 	int ch;
650 
651 	while ((ch = getopt(argc, argv, "")) != -1)
652 		ctl_usage(res->ctl);
653 	argc -= optind;
654 	argv += optind;
655 
656 	if (argc > 1)
657 		ctl_usage(res->ctl);
658 
659 	res->fp = stdin;
660 	if (argc == 1) {
661 		if ((res->fp = fopen(argv[0], "r")) == NULL)
662 			fatal("can't open %s", argv[0]);
663 	}
664 
665 	return ctlaction(res);
666 }
667 
668 static int
669 ctl_jump(struct parse_result *res, int argc, char **argv)
670 {
671 	int ch;
672 
673 	while ((ch = getopt(argc, argv, "")) != -1)
674 		ctl_usage(res->ctl);
675 	argc -= optind;
676 	argv += optind;
677 
678 	if (argc != 1)
679 		ctl_usage(res->ctl);
680 
681 	res->files = argv;
682 	return ctlaction(res);
683 }
684 
685 static int
686 parse_mode(struct parse_result *res, const char *v)
687 {
688 	if (v == NULL)
689 		return MODE_TOGGLE;
690 	if (!strcmp(v, "on"))
691 		return MODE_ON;
692 	if (!strcmp(v, "off"))
693 		return MODE_OFF;
694 	ctl_usage(res->ctl);
695 }
696 
697 static int
698 ctl_repeat(struct parse_result *res, int argc, char **argv)
699 {
700 	int ch;
701 
702 	while ((ch = getopt(argc, argv, "")) != -1)
703 		ctl_usage(res->ctl);
704 	argc -= optind;
705 	argv += optind;
706 
707 	if (argc != 1 && argc != 2)
708 		ctl_usage(res->ctl);
709 
710 	if (!strcmp(argv[0], "one"))
711 		res->mode.repeat_one = parse_mode(res, argv[1]);
712 	else if (!strcmp(argv[0], "all"))
713 		res->mode.repeat_all = parse_mode(res, argv[1]);
714 	else
715 		ctl_usage(res->ctl);
716 
717 	return ctlaction(res);
718 }
719 
720 static int
721 ctl_consume(struct parse_result *res, int argc, char **argv)
722 {
723 	int ch;
724 
725 	while ((ch = getopt(argc, argv, "")) != -1)
726 		ctl_usage(res->ctl);
727 	argc -= optind;
728 	argv += optind;
729 
730 	if (argc > 1)
731 		ctl_usage(res->ctl);
732 
733 	res->mode.consume = parse_mode(res, argv[0]);
734 	return ctlaction(res);
735 }
736 
737 static int
738 ctl_monitor(struct parse_result *res, int argc, char **argv)
739 {
740 	int ch, n = 0;
741 	const char *events;
742 	char *dup, *tmp, *tok;
743 
744 	while ((ch = getopt(argc, argv, "")) != -1)
745 		ctl_usage(res->ctl);
746 	argc -= optind;
747 	argv += optind;
748 
749 	if (argc > 1)
750 		ctl_usage(res->ctl);
751 
752 	events = "play,pause,stop,next,prev,jump,mode,add,load,seek";
753 	if (argc == 1)
754 		events = *argv;
755 
756 	tmp = dup = xstrdup(events);
757 	while ((tok = strsep(&tmp, ",")) != NULL) {
758 		if (*tok == '\0')
759 			continue;
760 
761 		n++;
762 		if (!strcmp(tok, "play"))
763 			res->monitor[IMSG_CTL_PLAY] = 1;
764 		else if (!strcmp(tok, "pause"))
765 			res->monitor[IMSG_CTL_PAUSE] = 1;
766 		else if (!strcmp(tok, "stop"))
767 			res->monitor[IMSG_CTL_STOP] = 1;
768 		else if (!strcmp(tok, "next"))
769 			res->monitor[IMSG_CTL_NEXT] = 1;
770 		else if (!strcmp(tok, "prev"))
771 			res->monitor[IMSG_CTL_PREV] = 1;
772 		else if (!strcmp(tok, "jump"))
773 			res->monitor[IMSG_CTL_JUMP] = 1;
774 		else if (!strcmp(tok, "mode"))
775 			res->monitor[IMSG_CTL_MODE] = 1;
776 		else if (!strcmp(tok, "add"))
777 			res->monitor[IMSG_CTL_ADD] = 1;
778 		else if (!strcmp(tok, "load"))
779 			res->monitor[IMSG_CTL_COMMIT] = 1;
780 		else if (!strcmp(tok, "seek"))
781 			res->monitor[IMSG_CTL_SEEK] = 1;
782 		else {
783 			log_warnx("unknown event \"%s\"", tok);
784 			n--;
785 		}
786 	}
787 
788 	free(dup);
789 	if (n == 0)
790 		ctl_usage(res->ctl);
791 	return ctlaction(res);
792 }
793 
794 static int
795 ctl_seek(struct parse_result *res, int argc, char **argv)
796 {
797 	const char *n;
798 	char *ep;
799 	int hours = 0, minutes = 0, seconds = 0;
800 	int sign = 1;
801 
802 	if (argc > 0) {
803 		/* skip the command name */
804 		argc--;
805 		argv++;
806 	}
807 
808 	if (argc > 0 && !strcmp(*argv, "--")) {
809 		argc--;
810 		argv++;
811 	}
812 
813 	if (argc != 1)
814 		ctl_usage(res->ctl);
815 
816 	n = *argv;
817 	if (*n == '-' || *n == '+')
818 		res->seek.relative = 1;
819 	if (*n == '-') {
820 		n++;
821 		sign = -1;
822 	}
823 
824 	seconds = strtol(n, &ep, 10);
825 	if (n[0] == '\0' ||
826 	    (*ep != '\0' && *ep != ':' && *ep != '%') ||
827 	    (*ep == '%' && ep[1] != '\0'))
828 		fatalx("invalid offset: %s", argv[0]);
829 	if (*ep == '\0' || *ep == '%') {
830 		res->seek.percent = *ep == '%';
831 		goto done;
832 	}
833 
834 	n = ++ep;
835 	minutes = seconds;
836 	seconds = strtol(n, &ep, 10);
837 	if (n[0] == '\0' || (*ep != '\0' && *ep != ':'))
838 		fatalx("invalid offset: %s", argv[0]);
839 	if (*ep == '\0')
840 		goto done;
841 
842 	n = ++ep;
843 	hours = minutes;
844 	minutes = seconds;
845 	seconds = strtol(n, &ep, 10);
846 	if (n[0] == '\0' || *ep != '\0')
847 		fatalx("invalid offset: %s", argv[0]);
848 
849 done:
850 	res->seek.offset = sign * (hours * 3600 + minutes * 60 + seconds);
851 	return ctlaction(res);
852 }
853 
854 static int
855 ctl_status(struct parse_result *res, int argc, char **argv)
856 {
857 	int ch;
858 
859 	while ((ch = getopt(argc, argv, "f:")) != -1) {
860 		switch (ch) {
861 		case 'f':
862 			res->status_format = optarg;
863 			break;
864 		default:
865 			ctl_usage(res->ctl);
866 		}
867 	}
868 	argc -= optind;
869 	argv += optind;
870 
871 	if (argc > 0)
872 		ctl_usage(res->ctl);
873 
874 	return ctlaction(res);
875 }
876 
877 static int
878 ctl_get_lock(const char *lockfile)
879 {
880 	int lockfd;
881 
882 	if ((lockfd = open(lockfile, O_WRONLY|O_CREAT, 0600)) == -1) {
883 		log_debug("open failed: %s", strerror(errno));
884 		return -1;
885 	}
886 
887 	if (flock(lockfd, LOCK_EX|LOCK_NB) == -1) {
888 		log_debug("flock failed: %s", strerror(errno));
889 		if (errno != EAGAIN)
890 			return -1;
891 		while (flock(lockfd, LOCK_EX) == -1 && errno == EINTR)
892 			/* nop */;
893 		close(lockfd);
894 		return -2;
895 	}
896 	log_debug("flock succeeded");
897 
898 	return lockfd;
899 }
900 
901 static int
902 ctl_connect(void)
903 {
904 	struct timespec		 ts = { 0, 50000000 }; /* 0.05 seconds */
905 	struct sockaddr_un	 sa;
906 	size_t			 size;
907 	int			 fd, lockfd = -1, locked = 0, spawned = 0;
908 	int			 attempt = 0;
909 	char			*lockfile = NULL;
910 
911 	memset(&sa, 0, sizeof(sa));
912 	sa.sun_family = AF_UNIX;
913 	size = strlcpy(sa.sun_path, csock, sizeof(sa.sun_path));
914 	if (size >= sizeof(sa.sun_path)) {
915 		errno = ENAMETOOLONG;
916 		return -1;
917 	}
918 
919 retry:
920 	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
921 		return -1;
922 
923 	if (connect(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
924 		log_debug("connection failed: %s", strerror(errno));
925 		if (errno != ECONNREFUSED && errno != ENOENT)
926 			goto failed;
927 		if (attempt++ == 100)
928 			goto failed;
929 		close(fd);
930 
931 		if (!locked) {
932 			xasprintf(&lockfile, "%s.lock", csock);
933 			if ((lockfd = ctl_get_lock(lockfile)) < 0) {
934 				log_debug("didn't get the lock (%d)", lockfd);
935 
936 				free(lockfile);
937 				lockfile = NULL;
938 
939 				if (lockfd == -1)
940 					goto retry;
941 			}
942 
943 			/*
944 			 * Always retry at least once, even if we got
945 			 * the lock, because another client could have
946 			 * taken the lock, started the server and released
947 			 * the lock between our connect() and flock()
948 			 */
949 			locked = 1;
950 			goto retry;
951 		}
952 
953 		if (!spawned) {
954 			log_debug("spawning the daemon");
955 			spawn_daemon();
956 			spawned = 1;
957 		}
958 
959 		nanosleep(&ts, NULL);
960 		goto retry;
961 	}
962 
963 	if (locked && lockfd >= 0) {
964 		unlink(lockfile);
965 		free(lockfile);
966 		close(lockfd);
967 	}
968 	return fd;
969 
970 failed:
971 	if (locked) {
972 		free(lockfile);
973 		close(lockfd);
974 	}
975 	close(fd);
976 	return -1;
977 }
978 
979 __dead void
980 ctl(int argc, char **argv)
981 {
982 	struct parse_result res;
983 	const char *fmt;
984 	int ctl_sock;
985 
986 	memset(&res, 0, sizeof(res));
987 	if ((fmt = getenv("AMUSED_STATUS_FORMAT")) == NULL)
988 		fmt = "status,time:oneline,mode:oneline";
989 	res.status_format = fmt;
990 
991 	res.mode.consume = MODE_UNDEF;
992 	res.mode.repeat_all = MODE_UNDEF;
993 	res.mode.repeat_one = MODE_UNDEF;
994 
995 	log_init(1, LOG_DAEMON);
996 	log_setverbose(verbose);
997 
998 	if (getcwd(cwd, sizeof(cwd)) == NULL)
999 		fatal("getcwd");
1000 
1001 	if ((ctl_sock = ctl_connect()) == -1)
1002 		fatal("can't connect");
1003 
1004 	imsgbuf = xmalloc(sizeof(*imsgbuf));
1005 	imsg_init(imsgbuf, ctl_sock);
1006 
1007 	optreset = 1;
1008 	optind = 1;
1009 
1010 	/* we'll drop rpath too later in ctlaction */
1011 	if (pledge("stdio rpath", NULL) == -1)
1012 		fatal("pledge");
1013 
1014 	exit(parse(&res, argc, argv));
1015 }