ap

command.c (5900B)

---

 /*
  * Copyright 2021-2024 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 <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 "queue.h"
 #include "util.h"
 
 char *
 com_add(struct aps *aps, int fd, int argc, char **argv)
 {
 	int i;
 	struct item *p;
 
 	p = NULL;
 	for (i = 0; i < argc; ++i) {
 		if (!(p = queue_add(aps, p, argv[i])))
 			return errstr;
 	}
 	return NULL;
 }
 
 char *
 com_remove(struct aps *aps, int fd, int argc, char **argv)
 {
 	struct item *match, *next;
 	struct search search;
 	char *err;
 
 	if (!argc) {
 		if (aps_bufline(aps, fd, aps->queue->path))
 			return errstr;
 		queue_remove(aps, aps->queue);
 		return NULL;
 	}
 
 	err = prepsearch(&search, aps->queue, *argv);
 	if (err)
 		return err;
 
 	while ((match = findnext(&search))) {
 		if (aps_bufline(aps, fd, match->path))
 			return errstr;
 
 		if (match == search.end) {
 			search.end = NULL;
 		}
 
 		if (match == aps->queue) {
 			next = queue_remove(aps, match);
 		} else {
 			next = queue_remove(aps, match);
 			if (next == aps->queue)
 				match = NULL;
 		}
 
 		if (!search.end) {
 			search.end = next;
 			search.new = 1;
 		}
 
 		if (next == NULL)
 			break;
 	}
 
 	return NULL;
 }
 
 char *
 com_list(struct aps *aps, int fd, int argc, char **argv)
 {
 	struct item *item;
 	struct search search;
 	char *err;
 
 	err = prepsearch(&search, aps->queue, argc ? *argv : "/^");
 	if (err)
 		return err;
 
 	if (aps->queue == NULL)
 		return NULL;
 
 	while ((item = findnext(&search))) {
 		if (aps_bufline(aps, fd, item->path))
 			return errstr;
 	}
 	stopsearch(&search);
 
 	return NULL;
 }
 
 char *
 com_seek(struct aps *aps, int fd, int argc, char **argv)
 {
 	char *err;
 
 	if (!argc)
 		return "No pattern";
 
 	if ((err = aps_seek(aps, *argv)))
 		return err;
 	if (aps_bufline(aps, fd, aps->queue->path))
 		return errstr;
 	return NULL;
 }
 
 char *
 com_play(struct aps *aps, int fd, int argc, char **argv)
 {
 	char *err;
 
 	if (argc && (err = com_seek(aps, fd, argc, argv)))
 		return err;
 	if (pplay(aps->player, aps->queue->path))
 		return errstr;
 	return NULL;
 }
 
 char *
 com_pause(struct aps *aps, int fd, int argc, char **argv)
 {
 	if (psuspend(aps->player))
 		return errstr;
 	return NULL;
 }
 
 char *
 com_stop(struct aps *aps, int fd, int argc, char **argv)
 {
 	if (pstop(aps->player))
 		return errstr;
 	return NULL;
 }
 
 char *
 com_toggle(struct aps *aps, int fd, int argc, char **argv)
 {
 	if (ptoggle(aps->player))
 		return errstr;
 	return com_status(aps, fd, 0, NULL);
 }
 
 char *
 com_name(struct aps *aps, int fd, int argc, char **argv)
 {
 	if (!aps->queue)
 		return "Empty queue";
 	if (aps_bufline(aps, fd, aps->queue->path))
 		return errstr;
 	return NULL;
 }
 
 char *
 com_next(struct aps *aps, int fd, int argc, char **argv)
 {
 	if (!aps->queue)
 		return "Empty queue";
 	if (aps_play(aps, aps->queue->next))
 		return errstr;
 	if (aps_bufline(aps, fd, aps->queue->path))
 		return errstr;
 	return NULL;
 }
 
 char *
 com_previous(struct aps *aps, int fd, int argc, char **argv)
 {
 	if (!aps->queue)
 		return "Empty queue";
 	if (aps_play(aps, aps->queue->prev))
 		return errstr;
 	if (aps_bufline(aps, fd, aps->queue->path))
 		return errstr;
 	return NULL;
 }
 
 char *
 com_status(struct aps *aps, int fd, int argc, char **argv)
 {
 	char *status;
 
 	switch (aps->player->state) {
 	case OFF:
 		status = "off";
 		break;
 	case RUNNING:
 		status = "running";
 		break;
 	case STOPPED:
 		status = "stopped";
 		break;
 	case SUSPENDED:
 		status = "suspended";
 		break;
 	case FAILURE:
 		status = "failure";
 		break;
 	case COMPLETE:
 		status = "complete";
 		break;
 	default:
 		bug("impossible player state");
 	}
 
 	if (aps_bufline(aps, fd, status))
 		return errstr;
 	return NULL;
 }
 
 char *
 com_log(struct aps *aps, int fd, int argc, char **argv)
 {
 	return "Command not currently implemented";
 }
 
 char *
 com_player(struct aps *aps, int fd, int argc, char **argv)
 {
 	int i;
 	struct player *new;
 
 	if (argc) {
 		new = pnew(argv);
 		if (new == NULL)
 			return errstr;
 		if (aps->player->state == STOPPED)
 			new->state = STOPPED;
 
 		pfree(aps->player);
 		aps->player = new;
 		return NULL;
 	}
 
 	for (i = 0; aps->player->argv[i]; ++i)
 		if (aps_bufword(aps, fd, aps->player->argv[i]))
 			return errstr;
 	return NULL;
 }
 
 char *
 com_truncate(struct aps *aps, int fd, int argc, char **argv)
 {
 	while (aps->queue && aps->queue->next != aps->queue)
 		queue_remove(aps, aps->queue->next);
 
 	if (!argc)
 		return NULL;
 	queue_remove(aps, aps->queue);
 	return com_add(aps, fd, argc, argv);
 }
 
 char *
 com_terminate(struct aps *aps, int fd, int argc, char **argv)
 {
 	aps->close = 1;
 	return NULL;
 }
 
 char *
 com_commands(struct aps *aps, int fd, int argc, char **argv)
 {
 	unsigned int i;
 
 	for (i = 0; i < aps->ncoms; ++i)
 		if (aps_bufline(aps, fd, aps->coms[i].name))
 			return errstr;
 	return NULL;
 }
 
 char *
 com_close(struct aps *aps, int fd, int argc, char **argv)
 {
 	return aps_unname(aps) ? errstr : NULL;
 }
 
 char *
 com_root(struct aps *aps, int fd, int argc, char **argv)
 {
 	char buf[PATH_MAX];
 
 	if (!getwd(buf))
 		return errstr;
 	if (aps_bufline(aps, fd, buf))
 		return errstr;
 	if (argc && chdir(argv[0]))
 		return errstr;
 	return NULL;
 }