ap

aps.c (6170B)

---

 /*
  * Copyright 2021-2023 Jacob R. Edwards
  *
  * ap -- audio player
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <sys/socket.h>
 #include <sys/stat.h>
 
 #include <ctype.h>
 #include <errno.h>
 #include <limits.h>
 #include <poll.h>
 #include <regex.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "aps.h"
 #include "arg.h"
 #include "buf.h"
 #include "bug.h"
 #include "command.h"
 #include "find.h"
 #include "log.h"
 #include "queue.h"
 #include "split.h"
 #include "util.h"
 
 struct aps *
 aps_open(char *path, char **player)
 {
 	int i;
 	struct aps *aps;
 
 	aps = calloc(1, sizeof(*aps));
 	if (aps == NULL)
 		return NULL;
 
 	for (i = 0; i < LEN(aps->pfds); ++i)
 		aps->pfds[i].fd = -1;
 
 	aps->player = pnew(player);
 	if (aps->player == NULL) {
 		aps_close(aps);
 		return NULL;
 	}
 
 	aps->con = apopen(path, bind, SOCK_NONBLOCK);
 	if (aps->con == NULL || listen(aps->con->sock, 10)) {
 		aps_close(aps);
 		return NULL;
 	}
 	aps->pfds[aps->con->sock].fd = aps->con->sock;
 	aps->pfds[aps->con->sock].events = POLLIN;
 
 	aps->timeout = INFTIM;
 
 	return aps;
 }
 
 void
 aps_close(struct aps *aps)
 {
 	int i;
 
 	if (aps == NULL)
 		return;
 
 	while (aps->queue)
 		queue_remove(aps, aps->queue);
 	pfree(aps->player);
 
 	for (i = 0; i < LEN(aps->clients); ++i)
 		if (aps->clients[i].request)
 			aps_drop(aps, i);
 	apclose(aps->con);
 
 	free(aps);
 }
 
 int
 aps_drop(struct aps *aps, int fd)
 {
 	aps_log(aps, fd, INFO, logsubjects[LogConn], "dropping client");
 	--aps->nfds;
 	aps->pfds[fd].fd = -1;
 	buffree(aps->clients[fd].response);
 	aps->clients[fd].response = NULL;
 	buffree(aps->clients[fd].request);
 	aps->clients[fd].request = NULL;
 	return sclose(fd);
 }
 
 int
 aps_addfd(struct aps *aps, int fd)
 {
 	if ((aps->clients[fd].request = bufnew()) == NULL)
 		return 1;
 	if ((aps->clients[fd].response = bufnew()) == NULL) {
 		buffree(aps->clients[fd].request);
 		return 1;
 	}
 
 	++aps->nfds;
 	aps->pfds[fd].fd = fd;
 	aps->pfds[fd].events = POLLIN;
 	return 0;
 }
 
 int
 aps_accept(struct aps *aps)
 {
 	int s;
 
 	while ((s = accept4(aps->con->sock, NULL, NULL, 0)) >= 0) {
 		if (aps_addfd(aps, s))
 			aps_log(aps, s, ERROR, logsubjects[LogConn], "unable to add client");
 		else
 			aps_log(aps, s, INFO, logsubjects[LogConn], "client added");
 	}
 
 	return errno != EWOULDBLOCK;
 }
 
 int
 aps_respond(struct aps *aps, int fd)
 {
 	ssize_t n;
 	struct buf *buf;
 
 	buf = aps->clients[fd].response;
 	n = send(fd, buf->data, buf->len, MSG_NOSIGNAL);
 	switch (n) {
 	case 0:
 		errno = ECONNRESET;
 		/* no break */
 	case -1:
 		return 1;
 	default:
 		if ((buf->len - n) == 0) {
 			buf->len = 0;
 			aps->pfds[fd].events = POLLIN;
 		} else {
 			bufshift(buf, n);
 		}
 		return 0;
 	}
 }
 
 int
 aps_handle(struct aps *aps, int fd)
 {
 	if (aps->pfds[fd].revents & (POLLERR | POLLHUP | POLLNVAL)) {
 		return 1;
 	} else if (aps->pfds[fd].revents & POLLIN) {
 		if (aps_command(aps, fd))
 			return 1;
 	} else if (aps->pfds[fd].revents & POLLOUT) {
 		if (aps_respond(aps, fd))
 			return 1;
 	} else {
 		bug("impossible poll event");
 	}
 
 	return 0;
 }
 
 int
 aps_named(struct aps *aps)
 {
 	struct stat sb;
 
 	return !stat(aps->con->path, &sb);
 }
 
 int
 aps_update(struct aps *aps)
 {
 	int i;
 	int re;
 
 	if ((re = poll(aps->pfds, LEN(aps->pfds), aps->timeout)) <= 0)
 		return re;
 
 	if (aps->pfds[aps->con->sock].revents) {
 		if ((aps->pfds[aps->con->sock].revents & POLLIN) && aps_accept(aps))
 			return 1;
 		aps->pfds[aps->con->sock].revents = 0;
 		--re;
 	}
 
 	for (i = 0; re > 0 && i < LEN(aps->pfds); ++i) {
 		if (aps->pfds[i].revents) {
 			if (aps_handle(aps, i))
 				aps_drop(aps, i);
 			--re;
 		}
 	}
 
 	if (!aps_named(aps) && !aps->nfds)
 		aps->close = 1;
 
 	return 0;
 }
 
 int
 aps_read(struct aps *aps, int fd, char **command)
 {
 	ssize_t len;
 
 	len = bufread(aps->clients[fd].request, fd, 4096);
 	if (len <= 0)
 		return -1;
 	return bufgetline(aps->clients[fd].request, command) < 0;
 }
 
 int
 aps_command(struct aps *aps, int fd)
 {
 	char *(*com)(struct aps *, int, int, char **);
 	char *buf, **argv;
 	char *status;
 	unsigned int i;
 
 	buf = NULL;
 	if (aps_read(aps, fd, &buf))
 		return -1;
 	if (buf == NULL)
 		return 0;
 
 	aps_log(aps, fd, DEBUG, logsubjects[LogCommand], "raw '%s'", buf);
 
 	argv = split(buf, NULL);
 	if (argv == NULL) {
 		status = "Unable to split arguments";
 		goto exit;
 	}
 	if (*argv == NULL) {
 		status = "No command";
 		goto exit;
 	}
 
 	aps_log(aps, fd, INFO, logsubjects[LogCommand], "running '%s' command", *argv);
 
 	for (com = NULL, i = 0; com == NULL && i < aps->ncoms; ++i)
 		if (strcmp(*argv, aps->coms[i].name) == 0)
 			com = aps->coms[i].func;
 
 	if (com == NULL)
 		status = "Command not found";
 	else
 		status = com(aps, fd, arglen(argv + 1), argv + 1);
 
 exit:
 	free(argv);
 	free(buf);
 	return aps_bufstatus(aps, fd, status);
 }
 
 void
 aps_errordrop(struct aps *aps, int fd, char *why)
 {
 	/* One could send(2) the error aswell. */
 	aps_log(aps, fd, ERROR, logsubjects[LogConn], why);
 	aps_drop(aps, fd);
 }
 
 char *
 aps_seek(struct aps *aps, char *pattern)
 {
 	char *err;
 	struct item *item;
 	struct search search;
 
 	if (!aps->queue)
 		return "Empty queue";
 
 	if ((err = prepsearch(&search, aps->queue, pattern)))
 		return err;
 
 	item = findnext(&search);
 	if (item == aps->queue)
 		item = findnext(&search);
 	stopsearch(&search);
 
 	if (item == NULL)
 		return "No match";
 	queue_set(aps, item);
 	return NULL;
 }
 
 int
 aps_play(struct aps *aps, struct item *item)
 {
 	queue_set(aps, item);
 	return pplay(aps->player, item->path);
 }
 
 int
 aps_unname(struct aps *aps)
 {
 	if (unlink(aps->con->path) == 0)
 		return 0;
 	aps_log(aps, 0, WARN, NULL, "%s: unable to remove socket", aps->con->path);
 	return 1;
 }