path: root/src/command.c

/* the Music Player Daemon (MPD)
 * Copyright (C) 2003-2007 by Warren Dukes (warren.dukes@gmail.com)
 * This project's homepage is: http://www.musicpd.org
 *
 * 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 2 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "command.h"
#include "player_control.h"
#include "playlist.h"
#include "ls.h"
#include "directory.h"
#include "database.h"
#include "update.h"
#include "volume.h"
#include "stats.h"
#include "list.h"
#include "permission.h"
#include "buffer2array.h"
#include "log.h"
#include "utils.h"
#include "storedPlaylist.h"
#include "sllist.h"
#include "ack.h"
#include "audio.h"
#include "dbUtils.h"
#include "tag.h"
#include "client.h"
#include "tag_print.h"
#include "path.h"
#include "os_compat.h"

#define COMMAND_PLAY           	"play"
#define COMMAND_PLAYID         	"playid"
#define COMMAND_STOP           	"stop"
#define COMMAND_PAUSE          	"pause"
#define COMMAND_STATUS         	"status"
#define COMMAND_KILL           	"kill"
#define COMMAND_CLOSE          	"close"
#define COMMAND_ADD            	"add"
#define COMMAND_ADDID		"addid"
#define COMMAND_DELETE         	"delete"
#define COMMAND_DELETEID       	"deleteid"
#define COMMAND_PLAYLIST       	"playlist"
#define COMMAND_SHUFFLE        	"shuffle"
#define COMMAND_CLEAR          	"clear"
#define COMMAND_SAVE           	"save"
#define COMMAND_LOAD           	"load"
#define COMMAND_LISTPLAYLIST   	"listplaylist"
#define COMMAND_LISTPLAYLISTINFO   	"listplaylistinfo"
#define COMMAND_LSINFO         	"lsinfo"
#define COMMAND_RM             	"rm"
#define COMMAND_PLAYLISTINFO   	"playlistinfo"
#define COMMAND_PLAYLISTID   	"playlistid"
#define COMMAND_FIND           	"find"
#define COMMAND_SEARCH         	"search"
#define COMMAND_UPDATE         	"update"
#define COMMAND_NEXT           	"next"
#define COMMAND_PREVIOUS       	"previous"
#define COMMAND_LISTALL        	"listall"
#define COMMAND_VOLUME         	"volume"
#define COMMAND_REPEAT         	"repeat"
#define COMMAND_RANDOM         	"random"
#define COMMAND_STATS          	"stats"
#define COMMAND_CLEAR_ERROR    	"clearerror"
#define COMMAND_LIST           	"list"
#define COMMAND_MOVE           	"move"
#define COMMAND_MOVEID         	"moveid"
#define COMMAND_SWAP           	"swap"
#define COMMAND_SWAPID      	"swapid"
#define COMMAND_SEEK           	"seek"
#define COMMAND_SEEKID         	"seekid"
#define COMMAND_LISTALLINFO	"listallinfo"
#define COMMAND_PING		"ping"
#define COMMAND_SETVOL		"setvol"
#define COMMAND_PASSWORD	"password"
#define COMMAND_CROSSFADE	"crossfade"
#define COMMAND_URL_HANDLERS   	"urlhandlers"
#define COMMAND_PLCHANGES	"plchanges"
#define COMMAND_PLCHANGESPOSID	"plchangesposid"
#define COMMAND_CURRENTSONG	"currentsong"
#define COMMAND_ENABLE_DEV	"enableoutput"
#define COMMAND_DISABLE_DEV	"disableoutput"
#define COMMAND_DEVICES		"outputs"
#define COMMAND_COMMANDS	"commands"
#define COMMAND_NOTCOMMANDS	"notcommands"
#define COMMAND_PLAYLISTCLEAR   "playlistclear"
#define COMMAND_PLAYLISTADD	"playlistadd"
#define COMMAND_PLAYLISTFIND	"playlistfind"
#define COMMAND_PLAYLISTSEARCH	"playlistsearch"
#define COMMAND_PLAYLISTMOVE	"playlistmove"
#define COMMAND_PLAYLISTDELETE	"playlistdelete"
#define COMMAND_TAGTYPES	"tagtypes"
#define COMMAND_COUNT		"count"
#define COMMAND_RENAME		"rename"

#define COMMAND_STATUS_VOLUME           "volume"
#define COMMAND_STATUS_STATE            "state"
#define COMMAND_STATUS_REPEAT           "repeat"
#define COMMAND_STATUS_RANDOM           "random"
#define COMMAND_STATUS_PLAYLIST         "playlist"
#define COMMAND_STATUS_PLAYLIST_LENGTH  "playlistlength"
#define COMMAND_STATUS_SONG             "song"
#define COMMAND_STATUS_SONGID           "songid"
#define COMMAND_STATUS_TIME             "time"
#define COMMAND_STATUS_BITRATE          "bitrate"
#define COMMAND_STATUS_ERROR            "error"
#define COMMAND_STATUS_CROSSFADE	"xfade"
#define COMMAND_STATUS_AUDIO		"audio"
#define COMMAND_STATUS_UPDATING_DB	"updating_db"

/*
 * The most we ever use is for search/find, and that limits it to the
 * number of tags we can have.  Add one for the command, and one extra
 * to catch errors clients may send us
 */
#define COMMAND_ARGV_MAX	(2+(TAG_NUM_OF_ITEM_TYPES*2))

typedef struct _CommandEntry CommandEntry;

typedef int (*CommandHandlerFunction) (struct client *, int, char **);

/* if min: -1 don't check args *
 * if max: -1 no max args      */
struct _CommandEntry {
	const char *cmd;
	int min;
	int max;
	int reqPermission;
	CommandHandlerFunction handler;
};

/* this should really be "need a non-negative integer": */
static const char need_positive[] = "need a positive integer"; /* no-op */

/* FIXME: redundant error messages */
static const char check_integer[] = "\"%s\" is not a integer";
static const char need_integer[] = "need an integer";
static const char check_boolean[] = "\"%s\" is not 0 or 1";
static const char check_non_negative[] = "\"%s\" is not an integer >= 0";

static const char *current_command;
static int command_listNum;

static List *commandList;

void command_success(struct client *client)
{
	client_puts(client, "OK\n");
}

static void command_error_v(struct client *client, int error,
			    const char *fmt, va_list args)
{
	assert(client != NULL);
	assert(current_command != NULL);

	client_printf(client, "ACK [%i@%i] {%s} ",
		      (int)error, command_listNum, current_command);
	client_vprintf(client, fmt, args);
	client_puts(client, "\n");

	current_command = NULL;
}

mpd_fprintf_ void command_error(struct client *client, int error,
				const char *fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	command_error_v(client, error, fmt, args);
	va_end(args);
}

static int mpd_fprintf__ check_uint32(struct client *client, uint32_t *dst,
                                      const char *s, const char *fmt, ...)
{
	char *test;

	*dst = strtoul(s, &test, 10);
	if (*test != '\0') {
		va_list args;
		va_start(args, fmt);
		command_error_v(client, ACK_ERROR_ARG, fmt, args);
		va_end(args);
		return -1;
	}
	return 0;
}

static int mpd_fprintf__ check_int(struct client *client, int *dst,
                                   const char *s, const char *fmt, ...)
{
	char *test;

	*dst = strtol(s, &test, 10);
	if (*test != '\0' ||
	    (fmt == check_boolean && *dst != 0 && *dst != 1) ||
	    (fmt == check_non_negative && *dst < 0)) {
		va_list args;
		va_start(args, fmt);
		command_error_v(client, ACK_ERROR_ARG, fmt, args);
		va_end(args);
		return -1;
	}
	return 0;
}

static int print_playlist_result(struct client *client,
				 enum playlist_result result)
{
	switch (result) {
	case PLAYLIST_RESULT_SUCCESS:
		return 0;

	case PLAYLIST_RESULT_ERRNO:
		command_error(client, ACK_ERROR_SYSTEM, strerror(errno));
		return -1;

	case PLAYLIST_RESULT_NO_SUCH_SONG:
		command_error(client, ACK_ERROR_NO_EXIST, "No such song");
		return -1;

	case PLAYLIST_RESULT_NO_SUCH_LIST:
		command_error(client, ACK_ERROR_NO_EXIST, "No such playlist");
		return -1;

	case PLAYLIST_RESULT_LIST_EXISTS:
		command_error(client, ACK_ERROR_NO_EXIST,
			      "Playlist already exists");
		return -1;

	case PLAYLIST_RESULT_BAD_NAME:
		command_error(client, ACK_ERROR_ARG,
			      "playlist name is invalid: "
			      "playlist names may not contain slashes,"
			      " newlines or carriage returns");
		return -1;

	case PLAYLIST_RESULT_BAD_RANGE:
		command_error(client, ACK_ERROR_ARG, "Bad song index");
		return -1;

	case PLAYLIST_RESULT_NOT_PLAYING:
		command_error(client, ACK_ERROR_PLAYER_SYNC, "Not playing");
		return -1;

	case PLAYLIST_RESULT_TOO_LARGE:
		command_error(client, ACK_ERROR_PLAYLIST_MAX,
			      "playlist is at the max size");
		return -1;
	}

	assert(0);
	return -1;
}

static void addCommand(const char *name,
		       int reqPermission,
		       int minargs,
		       int maxargs,
		       CommandHandlerFunction handler_func)
{
	CommandEntry *cmd = xmalloc(sizeof(CommandEntry));
	cmd->cmd = name;
	cmd->min = minargs;
	cmd->max = maxargs;
	cmd->handler = handler_func;
	cmd->reqPermission = reqPermission;

	insertInList(commandList, cmd->cmd, cmd);
}

static int handleUrlHandlers(struct client *client,
			     mpd_unused int argc, mpd_unused char *argv[])
{
	return printRemoteUrlHandlers(client);
}

static int handleTagTypes(struct client *client,
			  mpd_unused int argc, mpd_unused char *argv[])
{
	tag_print_types(client);
	return 0;
}

static int handlePlay(struct client *client,
		      int argc, char *argv[])
{
	int song = -1;
	enum playlist_result result;

	if (argc == 2 && check_int(client, &song, argv[1], need_positive) < 0)
		return -1;
	result = playPlaylist(song, 0);
	return print_playlist_result(client, result);
}

static int handlePlayId(struct client *client,
			int argc, char *argv[])
{
	int id = -1;
	enum playlist_result result;

	if (argc == 2 && check_int(client, &id, argv[1], need_positive) < 0)
		return -1;

	result = playPlaylistById(id, 0);
	return print_playlist_result(client, result);
}

static int handleStop(mpd_unused struct client *client,
		      mpd_unused int argc, mpd_unused char *argv[])
{
	stopPlaylist();
	return 0;
}

static int handleCurrentSong(struct client *client,
			     mpd_unused int argc, mpd_unused char *argv[])
{
	int song = getPlaylistCurrentSong();
	enum playlist_result result;

	if (song < 0)
		return 0;

	result = playlistInfo(client, song);
	return print_playlist_result(client, result);
}

static int handlePause(struct client *client,
		       int argc, char *argv[])
{
	if (argc == 2) {
		int pause_flag;
		if (check_int(client, &pause_flag, argv[1], check_boolean, argv[1]) < 0)
			return -1;
		playerSetPause(pause_flag);
		return 0;
	}

	playerPause();
	return 0;
}

static int commandStatus(struct client *client,
			 mpd_unused int argc, mpd_unused char *argv[])
{
	const char *state = NULL;
	int updateJobId;
	int song;

	playPlaylistIfPlayerStopped();
	switch (getPlayerState()) {
	case PLAYER_STATE_STOP:
		state = COMMAND_STOP;
		break;
	case PLAYER_STATE_PAUSE:
		state = COMMAND_PAUSE;
		break;
	case PLAYER_STATE_PLAY:
		state = COMMAND_PLAY;
		break;
	}

	client_printf(client,
		      COMMAND_STATUS_VOLUME ": %i\n"
		      COMMAND_STATUS_REPEAT ": %i\n"
		      COMMAND_STATUS_RANDOM ": %i\n"
		      COMMAND_STATUS_PLAYLIST ": %li\n"
		      COMMAND_STATUS_PLAYLIST_LENGTH ": %i\n"
		      COMMAND_STATUS_CROSSFADE ": %i\n"
		      COMMAND_STATUS_STATE ": %s\n",
		      getVolumeLevel(),
		      getPlaylistRepeatStatus(),
		      getPlaylistRandomStatus(),
		      getPlaylistVersion(),
		      getPlaylistLength(),
		      (int)(getPlayerCrossFade() + 0.5),
		      state);

	song = getPlaylistCurrentSong();
	if (song >= 0) {
		client_printf(client,
			      COMMAND_STATUS_SONG ": %i\n"
			      COMMAND_STATUS_SONGID ": %i\n",
			      song, getPlaylistSongId(song));
	}
	if (getPlayerState() != PLAYER_STATE_STOP) {
		client_printf(client,
			      COMMAND_STATUS_TIME ": %i:%i\n"
			      COMMAND_STATUS_BITRATE ": %li\n"
			      COMMAND_STATUS_AUDIO ": %u:%i:%i\n",
			      getPlayerElapsedTime(), getPlayerTotalTime(),
			      getPlayerBitRate(),
			      getPlayerSampleRate(), getPlayerBits(),
			      getPlayerChannels());
	}

	if ((updateJobId = isUpdatingDB())) {
		client_printf(client,
			      COMMAND_STATUS_UPDATING_DB ": %i\n",
			      updateJobId);
	}

	if (getPlayerError() != PLAYER_ERROR_NOERROR) {
		client_printf(client,
			      COMMAND_STATUS_ERROR ": %s\n",
			      getPlayerErrorStr());
	}

	return 0;
}

static int handleKill(mpd_unused struct client *client,
		      mpd_unused int argc, mpd_unused char *argv[])
{
	return COMMAND_RETURN_KILL;
}

static int handleClose(mpd_unused struct client *client,
		       mpd_unused int argc, mpd_unused char *argv[])
{
	return COMMAND_RETURN_CLOSE;
}

static int handleAdd(struct client *client,
		     mpd_unused int argc, char *argv[])
{
	char *path = argv[1];
	enum playlist_result result;

	if (isRemoteUrl(path))
		return addToPlaylist(path, NULL);

	result = addAllIn(path);
	if (result == (enum playlist_result)-1) {
		command_error(client, ACK_ERROR_NO_EXIST,
			      "directory or file not found");
		return -1;
	}

	return print_playlist_result(client, result);
}

static int handleAddId(struct client *client,
		       int argc, char *argv[])
{
	int added_id;
	enum playlist_result result = addToPlaylist(argv[1], &added_id);

	if (result != PLAYLIST_RESULT_SUCCESS)
		return result;

	if (argc == 3) {
		int to;
		if (check_int(client, &to, argv[2],
			      check_integer, argv[2]) < 0)
			return -1;
		result = moveSongInPlaylistById(added_id, to);
		if (result != PLAYLIST_RESULT_SUCCESS) {
			int ret = print_playlist_result(client, result);
			deleteFromPlaylistById(added_id);
			return ret;
		}
	}

	client_printf(client, "Id: %d\n", added_id);
	return result;
}

static int handleDelete(struct client *client,
			mpd_unused int argc, char *argv[])
{
	int song;
	enum playlist_result result;

	if (check_int(client, &song, argv[1], need_positive) < 0)
		return -1;

	result = deleteFromPlaylist(song);
	return print_playlist_result(client, result);
}

static int handleDeleteId(struct client *client,
			  mpd_unused int argc, char *argv[])
{
	int id;
	enum playlist_result result;

	if (check_int(client, &id, argv[1], need_positive) < 0)
		return -1;

	result = deleteFromPlaylistById(id);
	return print_playlist_result(client, result);
}

static int handlePlaylist(struct client *client,
			  mpd_unused int argc, mpd_unused char *argv[])
{
	showPlaylist(client);
	return 0;
}

static int handleShuffle(mpd_unused struct client *client,
			 mpd_unused int argc, mpd_unused char *argv[])
{
	shufflePlaylist();
	return 0;
}

static int handleClear(mpd_unused struct client *client,
		       mpd_unused int argc, mpd_unused char *argv[])
{
	clearPlaylist();
	return 0;
}

static int handleSave(struct client *client,
		      mpd_unused int argc, char *argv[])
{
	enum playlist_result result;

	result = savePlaylist(argv[1]);
	return print_playlist_result(client, result);
}

static int handleLoad(struct client *client,
		      mpd_unused int argc, char *argv[])
{
	enum playlist_result result;

	result = loadPlaylist(client, argv[1]);
	return print_playlist_result(client, result);
}

static int handleListPlaylist(struct client *client,
			      mpd_unused int argc, char *argv[])
{
	int ret;

	ret = PlaylistInfo(client, argv[1], 0);
	if (ret == -1)
		command_error(client, ACK_ERROR_NO_EXIST, "No such playlist");

	return ret;
}

static int handleListPlaylistInfo(struct client *client,
				  mpd_unused int argc, char *argv[])
{
	int ret;

	ret = PlaylistInfo(client, argv[1], 1);
	if (ret == -1)
		command_error(client, ACK_ERROR_NO_EXIST, "No such playlist");

	return ret;
}

static int handleLsInfo(struct client *client,
			int argc, char *argv[])
{
	const char *path = "";
	const struct directory *directory;

	if (argc == 2)
		path = argv[1];

	directory = db_get_directory(path);
	if (directory == NULL) {
		command_error(client, ACK_ERROR_NO_EXIST,
			      "directory not found");
		return -1;
	}

	directory_print(client, directory);

	if (isRootDirectory(path))
		return lsPlaylists(client, path);

	return 0;
}

static int handleRm(struct client *client,
		    mpd_unused int argc, char *argv[])
{
	enum playlist_result result;

	result = deletePlaylist(argv[1]);
	return print_playlist_result(client, result);
}

static int handleRename(struct client *client,
			mpd_unused int argc, char *argv[])
{
	enum playlist_result result;

	result = renameStoredPlaylist(argv[1], argv[2]);
	return print_playlist_result(client, result);
}

static int handlePlaylistChanges(struct client *client,
				 mpd_unused int argc, char *argv[])
{
	uint32_t version;

	if (check_uint32(client, &version, argv[1], need_positive) < 0)
		return -1;
	return playlistChanges(client, version);
}

static int handlePlaylistChangesPosId(struct client *client,
				      mpd_unused int argc, char *argv[])
{
	uint32_t version;

	if (check_uint32(client, &version, argv[1], need_positive) < 0)
		return -1;
	return playlistChangesPosId(client, version);
}

static int handlePlaylistInfo(struct client *client,
			      int argc, char *argv[])
{
	int song = -1;
	enum playlist_result result;

	if (argc == 2 && check_int(client, &song, argv[1], need_positive) < 0)
		return -1;

	result = playlistInfo(client, song);
	return print_playlist_result(client, result);
}

static int handlePlaylistId(struct client *client,
			    int argc, char *argv[])
{
	int id = -1;
	enum playlist_result result;

	if (argc == 2 && check_int(client, &id, argv[1], need_positive) < 0)
		return -1;

	result = playlistId(client, id);
	return print_playlist_result(client, result);
}

static int handleFind(struct client *client,
		      int argc, char *argv[])
{
	int ret;

	LocateTagItem *items;
	int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
							 argc - 1,
							 &items);

	if (numItems <= 0) {
		command_error(client, ACK_ERROR_ARG, "incorrect arguments");
		return -1;
	}

	ret = findSongsIn(client, NULL, numItems, items);
	if (ret == -1)
		command_error(client, ACK_ERROR_NO_EXIST,
			      "directory or file not found");

	freeLocateTagItemArray(numItems, items);

	return ret;
}

static int handleSearch(struct client *client,
			int argc, char *argv[])
{
	int ret;

	LocateTagItem *items;
	int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
							 argc - 1,
							 &items);

	if (numItems <= 0) {
		command_error(client, ACK_ERROR_ARG, "incorrect arguments");
		return -1;
	}

	ret = searchForSongsIn(client, NULL, numItems, items);
	if (ret == -1)
		command_error(client, ACK_ERROR_NO_EXIST,
			      "directory or file not found");

	freeLocateTagItemArray(numItems, items);

	return ret;
}

static int handleCount(struct client *client,
		       int argc, char *argv[])
{
	int ret;

	LocateTagItem *items;
	int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
							 argc - 1,
							 &items);

	if (numItems <= 0) {
		command_error(client, ACK_ERROR_ARG, "incorrect arguments");
		return -1;
	}

	ret = searchStatsForSongsIn(client, NULL, numItems, items);
	if (ret == -1)
		command_error(client, ACK_ERROR_NO_EXIST,
			      "directory or file not found");

	freeLocateTagItemArray(numItems, items);

	return ret;
}

static int handlePlaylistFind(struct client *client,
			      int argc, char *argv[])
{
	LocateTagItem *items;
	int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
							 argc - 1,
							 &items);

	if (numItems <= 0) {
		command_error(client, ACK_ERROR_ARG, "incorrect arguments");
		return -1;
	}

	findSongsInPlaylist(client, numItems, items);

	freeLocateTagItemArray(numItems, items);

	return 0;
}

static int handlePlaylistSearch(struct client *client,
				int argc, char *argv[])
{
	LocateTagItem *items;
	int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
							 argc - 1,
							 &items);

	if (numItems <= 0) {
		command_error(client, ACK_ERROR_ARG, "incorrect arguments");
		return -1;
	}

	searchForSongsInPlaylist(client, numItems, items);

	freeLocateTagItemArray(numItems, items);

	return 0;
}

static int handlePlaylistDelete(struct client *client,
				mpd_unused int argc, char *argv[]) {
	char *playlist = argv[1];
	int from;
	enum playlist_result result;

	if (check_int(client, &from, argv[2], check_integer, argv[2]) < 0)
		return -1;

	result = removeOneSongFromStoredPlaylistByPath(playlist, from);
	return print_playlist_result(client, result);
}

static int handlePlaylistMove(struct client *client,
			      mpd_unused mpd_unused int argc, char *argv[])
{
	char *playlist = argv[1];
	int from, to;
	enum playlist_result result;

	if (check_int(client, &from, argv[2], check_integer, argv[2]) < 0)
		return -1;
	if (check_int(client, &to, argv[3], check_integer, argv[3]) < 0)
		return -1;

	result = moveSongInStoredPlaylistByPath(playlist, from, to);
	return print_playlist_result(client, result);
}

static int print_update_result(struct client *client, int ret)
{
	if (ret >= 0) {
		client_printf(client, "updating_db: %i\n", ret);
		return 0;
	}
	if (ret == -2)
		command_error(client, ACK_ERROR_ARG, "invalid path");
	else
		command_error(client, ACK_ERROR_UPDATE_ALREADY,
			      "already updating");
	return -1;
}

static int handleUpdate(struct client *client,
			mpd_unused int argc, char *argv[])
{
	char *path = NULL;

	assert(argc <= 2);
	if (argc == 2 && !(path = sanitizePathDup(argv[1]))) {
		command_error(client, ACK_ERROR_ARG, "invalid path");
		return -1;
	}
	return print_update_result(client, directory_update_init(path));
}

static int handleNext(mpd_unused struct client *client,
		      mpd_unused int argc, mpd_unused char *argv[])
{
	nextSongInPlaylist();
	return 0;
}

static int handlePrevious(mpd_unused struct client *client,
			  mpd_unused int argc, mpd_unused char *argv[])
{
	previousSongInPlaylist();
	return 0;
}

static int handleListAll(struct client *client,
			 mpd_unused int argc, char *argv[])
{
	char *directory = NULL;
	int ret;

	if (argc == 2)
		directory = argv[1];

	ret = printAllIn(client, directory);
	if (ret == -1)
		command_error(client, ACK_ERROR_NO_EXIST,
			      "directory or file not found");

	return ret;
}

static int handleVolume(struct client *client,
			mpd_unused int argc, char *argv[])
{
	int change, ret;

	if (check_int(client, &change, argv[1], need_integer) < 0)
		return -1;

	ret = changeVolumeLevel(change, 1);
	if (ret == -1)
		command_error(client, ACK_ERROR_SYSTEM,
			      "problems setting volume");

	return ret;
}

static int handleSetVol(struct client *client,
			mpd_unused int argc, char *argv[])
{
	int level, ret;

	if (check_int(client, &level, argv[1], need_integer) < 0)
		return -1;

	ret = changeVolumeLevel(level, 0);
	if (ret == -1)
		command_error(client, ACK_ERROR_SYSTEM,
			      "problems setting volume");

	return ret;
}

static int handleRepeat(struct client *client,
			mpd_unused int argc, char *argv[])
{
	int status;

	if (check_int(client, &status, argv[1], need_integer) < 0)
		return -1;

	if (status != 0 && status != 1) {
		command_error(client, ACK_ERROR_ARG,
			      "\"%i\" is not 0 or 1", status);
		return -1;
	}

	setPlaylistRepeatStatus(status);
	return 0;
}

static int handleRandom(struct client *client,
			mpd_unused int argc, char *argv[])
{
	int status;

	if (check_int(client, &status, argv[1], need_integer) < 0)
		return -1;

	if (status != 0 && status != 1) {
		command_error(client, ACK_ERROR_ARG,
			      "\"%i\" is not 0 or 1", status);
		return -1;
	}

	setPlaylistRandomStatus(status);
	return 0;
}

static int handleStats(struct client *client,
		       mpd_unused int argc, mpd_unused char *argv[])
{
	return printStats(client);
}

static int handleClearError(mpd_unused struct client *client,
			    mpd_unused int argc, mpd_unused char *argv[])
{
	clearPlayerError();
	return 0;
}

static int handleList(struct client *client,
		      int argc, char *argv[])
{
	int numConditionals;
	LocateTagItem *conditionals = NULL;
	int tagType = getLocateTagItemType(argv[1]);
	int ret;

	if (tagType < 0) {
		command_error(client, ACK_ERROR_ARG, "\"%s\" is not known", argv[1]);
		return -1;
	}

	if (tagType == LOCATE_TAG_ANY_TYPE) {
		command_error(client, ACK_ERROR_ARG,
			      "\"any\" is not a valid return tag type");
		return -1;
	}

	/* for compatibility with < 0.12.0 */
	if (argc == 3) {
		if (tagType != TAG_ITEM_ALBUM) {
			command_error(client, ACK_ERROR_ARG,
				      "should be \"%s\" for 3 arguments",
				      mpdTagItemKeys[TAG_ITEM_ALBUM]);
			return -1;
		}
		conditionals = newLocateTagItem(mpdTagItemKeys[TAG_ITEM_ARTIST],
						argv[2]);
		numConditionals = 1;
	} else {
		numConditionals =
		    newLocateTagItemArrayFromArgArray(argv + 2,
						      argc - 2, &conditionals);

		if (numConditionals < 0) {
			command_error(client, ACK_ERROR_ARG,
				      "not able to parse args");
			return -1;
		}
	}

	ret = listAllUniqueTags(client, tagType, numConditionals, conditionals);

	if (conditionals)
		freeLocateTagItemArray(numConditionals, conditionals);

	if (ret == -1)
		command_error(client, ACK_ERROR_NO_EXIST,
			      "directory or file not found");

	return ret;
}

static int handleMove(struct client *client,
		      mpd_unused int argc, char *argv[])
{
	int from, to;
	enum playlist_result result;

	if (check_int(client, &from, argv[1], check_integer, argv[1]) < 0)
		return -1;
	if (check_int(client, &to, argv[2], check_integer, argv[2]) < 0)
		return -1;
	result = moveSongInPlaylist(from, to);
	return print_playlist_result(client, result);
}

static int handleMoveId(struct client *client,
			mpd_unused int argc, char *argv[])
{
	int id, to;
	enum playlist_result result;

	if (check_int(client, &id, argv[1], check_integer, argv[1]) < 0)
		return -1;
	if (check_int(client, &to, argv[2], check_integer, argv[2]) < 0)
		return -1;
	result = moveSongInPlaylistById(id, to);
	return print_playlist_result(client, result);
}

static int handleSwap(struct client *client,
		      mpd_unused int argc, char *argv[])
{
	int song1, song2;
	enum playlist_result result;

	if (check_int(client, &song1, argv[1], check_integer, argv[1]) < 0)
		return -1;
	if (check_int(client, &song2, argv[2], check_integer, argv[2]) < 0)
		return -1;
	result = swapSongsInPlaylist(song1, song2);
	return print_playlist_result(client, result);
}

static int handleSwapId(struct client *client,
			mpd_unused int argc, char *argv[])
{
	int id1, id2;
	enum playlist_result result;

	if (check_int(client, &id1, argv[1], check_integer, argv[1]) < 0)
		return -1;
	if (check_int(client, &id2, argv[2], check_integer, argv[2]) < 0)
		return -1;
	result = swapSongsInPlaylistById(id1, id2);
	return print_playlist_result(client, result);
}

static int handleSeek(struct client *client,
		      mpd_unused int argc, char *argv[])
{
	int song, seek_time;
	enum playlist_result result;

	if (check_int(client, &song, argv[1], check_integer, argv[1]) < 0)
		return -1;
	if (check_int(client, &seek_time, argv[2], check_integer, argv[2]) < 0)
		return -1;

	result = seekSongInPlaylist(song, seek_time);
	return print_playlist_result(client, result);
}

static int handleSeekId(struct client *client,
			mpd_unused int argc, char *argv[])
{
	int id, seek_time;
	enum playlist_result result;

	if (check_int(client, &id, argv[1], check_integer, argv[1]) < 0)
		return -1;
	if (check_int(client, &seek_time, argv[2], check_integer, argv[2]) < 0)
		return -1;

	result = seekSongInPlaylistById(id, seek_time);
	return print_playlist_result(client, result);
}

static int handleListAllInfo(struct client *client,
			     mpd_unused int argc, char *argv[])
{
	char *directory = NULL;
	int ret;

	if (argc == 2)
		directory = argv[1];

	ret = printInfoForAllIn(client, directory);
	if (ret == -1)
		command_error(client, ACK_ERROR_NO_EXIST,
			      "directory or file not found");

	return ret;
}

static int handlePing(mpd_unused struct client *client,
		      mpd_unused int argc, mpd_unused char *argv[])
{
	return 0;
}

static int handlePassword(struct client *client,
			  mpd_unused int argc, char *argv[])
{
	int permission = 0;

	if (getPermissionFromPassword(argv[1], &permission) < 0) {
		command_error(client, ACK_ERROR_PASSWORD, "incorrect password");
		return -1;
	}

	client_set_permission(client, permission);

	return 0;
}

static int handleCrossfade(struct client *client,
			   mpd_unused int argc, char *argv[])
{
	int xfade_time;

	if (check_int(client, &xfade_time, argv[1], check_non_negative, argv[1]) < 0)
		return -1;
	setPlayerCrossFade(xfade_time);

	return 0;
}

static int handleEnableDevice(struct client *client,
			      mpd_unused int argc, char *argv[])
{
	int device, ret;

	if (check_int(client, &device, argv[1], check_non_negative, argv[1]) < 0)
		return -1;

	ret = enableAudioDevice(device);
	if (ret == -1)
		command_error(client, ACK_ERROR_NO_EXIST,
			      "No such audio output");

	return ret;
}

static int handleDisableDevice(struct client *client,
			       mpd_unused int argc, char *argv[])
{
	int device, ret;

	if (check_int(client, &device, argv[1], check_non_negative, argv[1]) < 0)
		return -1;

	ret = disableAudioDevice(device);
	if (ret == -1)
		command_error(client, ACK_ERROR_NO_EXIST,
			      "No such audio output");

	return ret;
}

static int handleDevices(struct client *client,
			 mpd_unused int argc, mpd_unused char *argv[])
{
	printAudioDevices(client);

	return 0;
}

/* don't be fooled, this is the command handler for "commands" command */
static int handleCommands(struct client *client,
			  mpd_unused int argc, mpd_unused char *argv[])
{
	const int permission = client_get_permission(client);
	ListNode *node = commandList->firstNode;
	CommandEntry *cmd;

	while (node != NULL) {
		cmd = (CommandEntry *) node->data;
		if (cmd->reqPermission == (permission & cmd->reqPermission)) {
			client_printf(client, "command: %s\n", cmd->cmd);
		}

		node = node->nextNode;
	}

	return 0;
}

static int handleNotcommands(struct client *client,
			     mpd_unused int argc, mpd_unused char *argv[])
{
	const int permission = client_get_permission(client);
	ListNode *node = commandList->firstNode;
	CommandEntry *cmd;

	while (node != NULL) {
		cmd = (CommandEntry *) node->data;

		if (cmd->reqPermission != (permission & cmd->reqPermission)) {
			client_printf(client, "command: %s\n", cmd->cmd);
		}

		node = node->nextNode;
	}

	return 0;
}

static int handlePlaylistClear(struct client *client,
			       mpd_unused int argc, char *argv[])
{
	enum playlist_result result;

	result = clearStoredPlaylist(argv[1]);
	return print_playlist_result(client, result);
}

static int handlePlaylistAdd(struct client *client,
			     mpd_unused int argc, char *argv[])
{
	char *playlist = argv[1];
	char *path = argv[2];
	enum playlist_result result;

	if (isRemoteUrl(path))
		result = addToStoredPlaylist(path, playlist);
	else
		result = addAllInToStoredPlaylist(path, playlist);

	if (result == (enum playlist_result)-1) {
		command_error(client, ACK_ERROR_NO_EXIST,
			      "directory or file not found");
		return -1;
	}

	return print_playlist_result(client, result);
}

void initCommands(void)
{
	commandList = makeList(free, 1);

	/* addCommand(name,                  permission,         min, max, handler); */
	addCommand(COMMAND_PLAY,             PERMISSION_CONTROL, 0,   1,   handlePlay);
	addCommand(COMMAND_PLAYID,           PERMISSION_CONTROL, 0,   1,   handlePlayId);
	addCommand(COMMAND_STOP,             PERMISSION_CONTROL, 0,   0,   handleStop);
	addCommand(COMMAND_CURRENTSONG,      PERMISSION_READ,    0,   0,   handleCurrentSong);
	addCommand(COMMAND_PAUSE,            PERMISSION_CONTROL, 0,   1,   handlePause);
	addCommand(COMMAND_STATUS,           PERMISSION_READ,    0,   0,   commandStatus);
	addCommand(COMMAND_KILL,             PERMISSION_ADMIN,   -1,  -1,  handleKill);
	addCommand(COMMAND_CLOSE,            PERMISSION_NONE,    -1,  -1,  handleClose);
	addCommand(COMMAND_ADD,              PERMISSION_ADD,     1,   1,   handleAdd);
	addCommand(COMMAND_ADDID,            PERMISSION_ADD,     1,   2,   handleAddId);
	addCommand(COMMAND_DELETE,           PERMISSION_CONTROL, 1,   1,   handleDelete);
	addCommand(COMMAND_DELETEID,         PERMISSION_CONTROL, 1,   1,   handleDeleteId);
	addCommand(COMMAND_PLAYLIST,         PERMISSION_READ,    0,   0,   handlePlaylist);
	addCommand(COMMAND_PLAYLISTID,       PERMISSION_READ,    0,   1,   handlePlaylistId);
	addCommand(COMMAND_SHUFFLE,          PERMISSION_CONTROL, 0,   0,   handleShuffle);
	addCommand(COMMAND_CLEAR,            PERMISSION_CONTROL, 0,   0,   handleClear);
	addCommand(COMMAND_SAVE,             PERMISSION_CONTROL, 1,   1,   handleSave);
	addCommand(COMMAND_LOAD,             PERMISSION_ADD,     1,   1,   handleLoad);
	addCommand(COMMAND_LISTPLAYLIST,     PERMISSION_READ,    1,   1,   handleListPlaylist);
	addCommand(COMMAND_LISTPLAYLISTINFO, PERMISSION_READ,    1,   1,   handleListPlaylistInfo);
	addCommand(COMMAND_LSINFO,           PERMISSION_READ,    0,   1,   handleLsInfo);
	addCommand(COMMAND_RM,               PERMISSION_CONTROL, 1,   1,   handleRm);
	addCommand(COMMAND_PLAYLISTINFO,     PERMISSION_READ,    0,   1,   handlePlaylistInfo);
	addCommand(COMMAND_FIND,             PERMISSION_READ,    2,   -1,  handleFind);
	addCommand(COMMAND_SEARCH,           PERMISSION_READ,    2,   -1,  handleSearch);
	addCommand(COMMAND_UPDATE,           PERMISSION_ADMIN,   0,   1,   handleUpdate);
	addCommand(COMMAND_NEXT,             PERMISSION_CONTROL, 0,   0,   handleNext);
	addCommand(COMMAND_PREVIOUS,         PERMISSION_CONTROL, 0,   0,   handlePrevious);
	addCommand(COMMAND_LISTALL,          PERMISSION_READ,    0,   1,   handleListAll);
	addCommand(COMMAND_VOLUME,           PERMISSION_CONTROL, 1,   1,   handleVolume);
	addCommand(COMMAND_REPEAT,           PERMISSION_CONTROL, 1,   1,   handleRepeat);
	addCommand(COMMAND_RANDOM,           PERMISSION_CONTROL, 1,   1,   handleRandom);
	addCommand(COMMAND_STATS,            PERMISSION_READ,    0,   0,   handleStats);
	addCommand(COMMAND_CLEAR_ERROR,      PERMISSION_CONTROL, 0,   0,   handleClearError);
	addCommand(COMMAND_LIST,             PERMISSION_READ,    1,   -1,  handleList);
	addCommand(COMMAND_MOVE,             PERMISSION_CONTROL, 2,   2,   handleMove);
	addCommand(COMMAND_MOVEID,           PERMISSION_CONTROL, 2,   2,   handleMoveId);
	addCommand(COMMAND_SWAP,             PERMISSION_CONTROL, 2,   2,   handleSwap);
	addCommand(COMMAND_SWAPID,           PERMISSION_CONTROL, 2,   2,   handleSwapId);
	addCommand(COMMAND_SEEK,             PERMISSION_CONTROL, 2,   2,   handleSeek);
	addCommand(COMMAND_SEEKID,           PERMISSION_CONTROL, 2,   2,   handleSeekId);
	addCommand(COMMAND_LISTALLINFO,      PERMISSION_READ,    0,   1,   handleListAllInfo);
	addCommand(COMMAND_PING,             PERMISSION_NONE,    0,   0,   handlePing);
	addCommand(COMMAND_SETVOL,           PERMISSION_CONTROL, 1,   1,   handleSetVol);
	addCommand(COMMAND_PASSWORD,         PERMISSION_NONE,    1,   1,   handlePassword);
	addCommand(COMMAND_CROSSFADE,        PERMISSION_CONTROL, 1,   1,   handleCrossfade);
	addCommand(COMMAND_URL_HANDLERS,     PERMISSION_READ,    0,   0,   handleUrlHandlers);
	addCommand(COMMAND_PLCHANGES,        PERMISSION_READ,    1,   1,   handlePlaylistChanges);
	addCommand(COMMAND_PLCHANGESPOSID,   PERMISSION_READ,    1,   1,   handlePlaylistChangesPosId);
	addCommand(COMMAND_ENABLE_DEV,       PERMISSION_ADMIN,   1,   1,   handleEnableDevice);
	addCommand(COMMAND_DISABLE_DEV,      PERMISSION_ADMIN,   1,   1,   handleDisableDevice);
	addCommand(COMMAND_DEVICES,          PERMISSION_READ,    0,   0,   handleDevices);
	addCommand(COMMAND_COMMANDS,         PERMISSION_NONE,    0,   0,   handleCommands);
	addCommand(COMMAND_NOTCOMMANDS,      PERMISSION_NONE,    0,   0,   handleNotcommands);
	addCommand(COMMAND_PLAYLISTCLEAR,    PERMISSION_CONTROL, 1,   1,   handlePlaylistClear);
	addCommand(COMMAND_PLAYLISTADD,      PERMISSION_CONTROL, 2,   2,   handlePlaylistAdd);
	addCommand(COMMAND_PLAYLISTFIND,     PERMISSION_READ,    2,   -1,  handlePlaylistFind);
	addCommand(COMMAND_PLAYLISTSEARCH,   PERMISSION_READ,    2,   -1,  handlePlaylistSearch);
	addCommand(COMMAND_PLAYLISTMOVE,     PERMISSION_CONTROL, 3,   3,   handlePlaylistMove);
	addCommand(COMMAND_PLAYLISTDELETE,   PERMISSION_CONTROL, 2,   2,   handlePlaylistDelete);
	addCommand(COMMAND_TAGTYPES,         PERMISSION_READ,    0,   0,   handleTagTypes);
	addCommand(COMMAND_COUNT,            PERMISSION_READ,    2,   -1,  handleCount);
	addCommand(COMMAND_RENAME,           PERMISSION_CONTROL, 2,   2,   handleRename);

	sortList(commandList);
}

void finishCommands(void)
{
	freeList(commandList);
}

static int checkArgcAndPermission(CommandEntry * cmd, struct client *client,
				  int permission, int argc, char *argv[])
{
	int min = cmd->min + 1;
	int max = cmd->max + 1;

	if (cmd->reqPermission != (permission & cmd->reqPermission)) {
		if (client != NULL)
			command_error(client, ACK_ERROR_PERMISSION,
				      "you don't have permission for \"%s\"",
				      cmd->cmd);
		return -1;
	}

	if (min == 0)
		return 0;

	if (min == max && max != argc) {
		if (client != NULL)
			command_error(client, ACK_ERROR_ARG,
				      "wrong number of arguments for \"%s\"",
				      argv[0]);
		return -1;
	} else if (argc < min) {
		if (client != NULL)
			command_error(client, ACK_ERROR_ARG,
				      "too few arguments for \"%s\"", argv[0]);
		return -1;
	} else if (argc > max && max /* != 0 */ ) {
		if (client != NULL)
			command_error(client, ACK_ERROR_ARG,
				      "too many arguments for \"%s\"", argv[0]);
		return -1;
	} else
		return 0;
}

static CommandEntry *getCommandEntryAndCheckArgcAndPermission(struct client *client,
							      int permission,
							      int argc,
							      char *argv[])
{
	static char unknown[] = "";
	CommandEntry *cmd;

	current_command = unknown;

	if (argc == 0)
		return NULL;

	if (!findInList(commandList, argv[0], (void *)&cmd)) {
		if (client != NULL)
			command_error(client, ACK_ERROR_UNKNOWN,
				      "unknown command \"%s\"", argv[0]);
		return NULL;
	}

	current_command = cmd->cmd;

	if (checkArgcAndPermission(cmd, client, permission, argc, argv) < 0) {
		return NULL;
	}

	return cmd;
}

int processCommand(struct client *client, char *commandString)
{
	int argc;
	char *argv[COMMAND_ARGV_MAX] = { NULL };
	CommandEntry *cmd;
	int ret = -1;

	if (!(argc = buffer2array(commandString, argv, COMMAND_ARGV_MAX)))
		return 0;

	cmd = getCommandEntryAndCheckArgcAndPermission(client,
						       client_get_permission(client),
						       argc, argv);
	if (cmd)
		ret = cmd->handler(client, argc, argv);

	current_command = NULL;

	return ret;
}

int processListOfCommands(struct client *client,
			  int listOK, struct strnode *list)
{
	struct strnode *cur = list;
	int ret = 0;

	command_listNum = 0;

	while (cur) {
		DEBUG("processListOfCommands: process command \"%s\"\n",
		      cur->data);
		ret = processCommand(client, cur->data);
		DEBUG("processListOfCommands: command returned %i\n", ret);
		if (ret != 0 || client_is_expired(client))
			goto out;
		else if (listOK)
			client_puts(client, "list_OK\n");
		command_listNum++;
		cur = cur->next;
	}
out:
	command_listNum = 0;
	return ret;
}