2004-02-24 00:41:20 +01:00
|
|
|
/* the Music Player Daemon (MPD)
|
2007-04-05 05:22:33 +02:00
|
|
|
* Copyright (C) 2003-2007 by Warren Dukes (warren.dukes@gmail.com)
|
2004-02-24 00:41:20 +01:00
|
|
|
* 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.h"
|
|
|
|
#include "playlist.h"
|
|
|
|
#include "ls.h"
|
|
|
|
#include "directory.h"
|
|
|
|
#include "volume.h"
|
|
|
|
#include "stats.h"
|
|
|
|
#include "myfprintf.h"
|
|
|
|
#include "list.h"
|
|
|
|
#include "permission.h"
|
2004-04-11 19:37:47 +02:00
|
|
|
#include "buffer2array.h"
|
2004-04-12 03:44:52 +02:00
|
|
|
#include "log.h"
|
2006-07-30 07:00:56 +02:00
|
|
|
#include "tag.h"
|
2006-08-26 08:25:57 +02:00
|
|
|
#include "utils.h"
|
2007-05-16 14:02:10 +02:00
|
|
|
#include "storedPlaylist.h"
|
2008-01-03 08:29:49 +01:00
|
|
|
#include "os_compat.h"
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-06-05 03:14:37 +02:00
|
|
|
#define COMMAND_PLAY "play"
|
2004-06-09 04:50:44 +02:00
|
|
|
#define COMMAND_PLAYID "playid"
|
2004-06-05 03:14:37 +02:00
|
|
|
#define COMMAND_STOP "stop"
|
|
|
|
#define COMMAND_PAUSE "pause"
|
|
|
|
#define COMMAND_STATUS "status"
|
|
|
|
#define COMMAND_KILL "kill"
|
|
|
|
#define COMMAND_CLOSE "close"
|
|
|
|
#define COMMAND_ADD "add"
|
2004-11-03 00:44:33 +01:00
|
|
|
#define COMMAND_ADDID "addid"
|
2004-06-05 03:14:37 +02:00
|
|
|
#define COMMAND_DELETE "delete"
|
2004-06-09 04:50:44 +02:00
|
|
|
#define COMMAND_DELETEID "deleteid"
|
2004-06-05 03:14:37 +02:00
|
|
|
#define COMMAND_PLAYLIST "playlist"
|
|
|
|
#define COMMAND_SHUFFLE "shuffle"
|
|
|
|
#define COMMAND_CLEAR "clear"
|
|
|
|
#define COMMAND_SAVE "save"
|
|
|
|
#define COMMAND_LOAD "load"
|
2006-03-26 19:43:52 +02:00
|
|
|
#define COMMAND_LISTPLAYLIST "listplaylist"
|
|
|
|
#define COMMAND_LISTPLAYLISTINFO "listplaylistinfo"
|
2004-06-05 03:14:37 +02:00
|
|
|
#define COMMAND_LSINFO "lsinfo"
|
|
|
|
#define COMMAND_RM "rm"
|
|
|
|
#define COMMAND_PLAYLISTINFO "playlistinfo"
|
2004-06-09 04:50:44 +02:00
|
|
|
#define COMMAND_PLAYLISTID "playlistid"
|
2004-06-05 03:14:37 +02:00
|
|
|
#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"
|
2004-06-09 04:50:44 +02:00
|
|
|
#define COMMAND_MOVEID "moveid"
|
2004-06-05 03:14:37 +02:00
|
|
|
#define COMMAND_SWAP "swap"
|
2004-06-09 04:50:44 +02:00
|
|
|
#define COMMAND_SWAPID "swapid"
|
2004-06-05 03:14:37 +02:00
|
|
|
#define COMMAND_SEEK "seek"
|
2004-06-09 04:50:44 +02:00
|
|
|
#define COMMAND_SEEKID "seekid"
|
2004-02-24 00:41:20 +01:00
|
|
|
#define COMMAND_LISTALLINFO "listallinfo"
|
|
|
|
#define COMMAND_PING "ping"
|
|
|
|
#define COMMAND_SETVOL "setvol"
|
|
|
|
#define COMMAND_PASSWORD "password"
|
|
|
|
#define COMMAND_CROSSFADE "crossfade"
|
2006-07-20 18:02:40 +02:00
|
|
|
#define COMMAND_URL_HANDLERS "urlhandlers"
|
|
|
|
#define COMMAND_PLCHANGES "plchanges"
|
|
|
|
#define COMMAND_PLCHANGESPOSID "plchangesposid"
|
|
|
|
#define COMMAND_CURRENTSONG "currentsong"
|
2004-11-14 06:38:49 +01:00
|
|
|
#define COMMAND_ENABLE_DEV "enableoutput"
|
|
|
|
#define COMMAND_DISABLE_DEV "disableoutput"
|
|
|
|
#define COMMAND_DEVICES "outputs"
|
2004-11-08 19:01:36 +01:00
|
|
|
#define COMMAND_COMMANDS "commands"
|
2004-11-23 20:46:33 +01:00
|
|
|
#define COMMAND_NOTCOMMANDS "notcommands"
|
2006-12-07 15:41:40 +01:00
|
|
|
#define COMMAND_PLAYLISTCLEAR "playlistclear"
|
|
|
|
#define COMMAND_PLAYLISTADD "playlistadd"
|
2007-02-24 03:00:03 +01:00
|
|
|
#define COMMAND_PLAYLISTFIND "playlistfind"
|
|
|
|
#define COMMAND_PLAYLISTSEARCH "playlistsearch"
|
2007-05-16 14:02:10 +02:00
|
|
|
#define COMMAND_PLAYLISTMOVE "playlistmove"
|
|
|
|
#define COMMAND_PLAYLISTDELETE "playlistdelete"
|
2007-03-31 20:43:16 +02:00
|
|
|
#define COMMAND_TAGTYPES "tagtypes"
|
2007-04-26 01:46:11 +02:00
|
|
|
#define COMMAND_COUNT "count"
|
2007-05-24 20:07:19 +02:00
|
|
|
#define COMMAND_RENAME "rename"
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
#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"
|
2004-06-09 04:50:44 +02:00
|
|
|
#define COMMAND_STATUS_SONGID "songid"
|
2004-02-24 00:41:20 +01:00
|
|
|
#define COMMAND_STATUS_TIME "time"
|
|
|
|
#define COMMAND_STATUS_BITRATE "bitrate"
|
|
|
|
#define COMMAND_STATUS_ERROR "error"
|
2004-02-27 02:35:23 +01:00
|
|
|
#define COMMAND_STATUS_CROSSFADE "xfade"
|
|
|
|
#define COMMAND_STATUS_AUDIO "audio"
|
2004-04-11 04:34:26 +02:00
|
|
|
#define COMMAND_STATUS_UPDATING_DB "updating_db"
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-10-06 12:33:27 +02:00
|
|
|
/*
|
|
|
|
* 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))
|
|
|
|
|
2004-04-11 19:37:47 +02:00
|
|
|
typedef struct _CommandEntry CommandEntry;
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
typedef int (*CommandHandlerFunction) (int, int *, int, char **);
|
2006-07-20 18:02:40 +02:00
|
|
|
typedef int (*CommandListHandlerFunction)
|
2006-07-30 05:43:38 +02:00
|
|
|
(int, int *, int, char **, struct strnode *, CommandEntry *);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
/* if min: -1 don't check args *
|
|
|
|
* if max: -1 no max args */
|
2004-04-11 19:37:47 +02:00
|
|
|
struct _CommandEntry {
|
2006-07-20 18:02:40 +02:00
|
|
|
char *cmd;
|
|
|
|
int min;
|
|
|
|
int max;
|
2006-07-17 23:46:32 +02:00
|
|
|
int reqPermission;
|
2006-07-20 18:02:40 +02:00
|
|
|
CommandHandlerFunction handler;
|
2004-04-11 19:37:47 +02:00
|
|
|
CommandListHandlerFunction listHandler;
|
|
|
|
};
|
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
|
|
|
|
/* 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";
|
|
|
|
|
2007-01-14 04:07:53 +01:00
|
|
|
static char *current_command;
|
|
|
|
static int command_listNum;
|
2004-06-04 03:58:31 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static CommandEntry *getCommandEntryFromString(char *string, int *permission);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
static List *commandList;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-08-20 02:50:44 +02:00
|
|
|
static CommandEntry *newCommandEntry(void)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2006-08-26 08:25:57 +02:00
|
|
|
CommandEntry *cmd = xmalloc(sizeof(CommandEntry));
|
2006-07-20 18:02:40 +02:00
|
|
|
cmd->cmd = NULL;
|
|
|
|
cmd->min = 0;
|
|
|
|
cmd->max = 0;
|
|
|
|
cmd->handler = NULL;
|
|
|
|
cmd->listHandler = NULL;
|
2004-02-24 00:41:20 +01:00
|
|
|
cmd->reqPermission = 0;
|
2006-07-20 18:02:40 +02:00
|
|
|
return cmd;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
static void command_error_va(int fd, int error, const char *fmt, va_list args)
|
|
|
|
{
|
|
|
|
if (current_command && fd != STDERR_FILENO) {
|
|
|
|
fdprintf(fd, "ACK [%i@%i] {%s} ",
|
|
|
|
(int)error, command_listNum, current_command);
|
|
|
|
vfdprintf(fd, fmt, args);
|
|
|
|
fdprintf(fd, "\n");
|
|
|
|
current_command = NULL;
|
|
|
|
} else {
|
|
|
|
fdprintf(STDERR_FILENO, "ACK [%i@%i] ",
|
|
|
|
(int)error, command_listNum);
|
|
|
|
vfdprintf(STDERR_FILENO, fmt, args);
|
|
|
|
fdprintf(STDERR_FILENO, "\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mpd_fprintf__ check_uint32(int fd, mpd_uint32 *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_va(fd, ACK_ERROR_ARG, fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mpd_fprintf__ check_int(int fd, 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_va(fd, ACK_ERROR_ARG, fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static void addCommand(char *name,
|
|
|
|
int reqPermission,
|
2006-07-17 23:46:32 +02:00
|
|
|
int minargs,
|
2006-07-20 18:02:40 +02:00
|
|
|
int maxargs,
|
2006-07-17 23:46:32 +02:00
|
|
|
CommandHandlerFunction handler_func,
|
2006-07-20 18:02:40 +02:00
|
|
|
CommandListHandlerFunction listHandler_func)
|
|
|
|
{
|
|
|
|
CommandEntry *cmd = newCommandEntry();
|
|
|
|
cmd->cmd = name;
|
|
|
|
cmd->min = minargs;
|
|
|
|
cmd->max = maxargs;
|
|
|
|
cmd->handler = handler_func;
|
|
|
|
cmd->listHandler = listHandler_func;
|
2004-02-24 00:41:20 +01:00
|
|
|
cmd->reqPermission = reqPermission;
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
insertInList(commandList, cmd->cmd, cmd);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleUrlHandlers(int fd, int *permission, int argc, char *argv[])
|
2004-06-03 01:22:37 +02:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return printRemoteUrlHandlers(fd);
|
2004-06-03 01:22:37 +02:00
|
|
|
}
|
|
|
|
|
2007-03-31 20:43:16 +02:00
|
|
|
static int handleTagTypes(int fd, int *permission, int argc, char *argv[])
|
|
|
|
{
|
|
|
|
printTagTypes(fd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handlePlay(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int song = -1;
|
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (argc == 2 && check_int(fd, &song, argv[1], need_positive) < 0)
|
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return playPlaylist(fd, song, 0);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handlePlayId(int fd, int *permission, int argc, char *argv[])
|
2004-06-09 04:50:44 +02:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int id = -1;
|
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (argc == 2 && check_int(fd, &id, argv[1], need_positive) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
return playPlaylistById(fd, id, 0);
|
2004-06-09 04:50:44 +02:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleStop(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return stopPlaylist(fd);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleCurrentSong(int fd, int *permission, int argc, char *argv[])
|
2004-06-10 06:13:23 +02:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int song = getPlaylistCurrentSong();
|
2004-06-10 06:13:23 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (song >= 0) {
|
2006-07-30 05:43:38 +02:00
|
|
|
return playlistInfo(fd, song);
|
2006-07-20 18:02:40 +02:00
|
|
|
} else
|
|
|
|
return 0;
|
2004-06-10 06:13:23 +02:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handlePause(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-29 20:54:56 +02:00
|
|
|
if (argc == 2) {
|
2008-01-26 13:46:53 +01:00
|
|
|
int pause_flag;
|
|
|
|
if (check_int(fd, &pause_flag, argv[1], check_boolean, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-01-26 13:46:21 +01:00
|
|
|
return playerSetPause(fd, pause_flag);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
2006-07-30 05:43:38 +02:00
|
|
|
return playerPause(fd);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int commandStatus(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
char *state = NULL;
|
2004-04-11 05:12:00 +02:00
|
|
|
int updateJobId;
|
2006-07-20 18:02:40 +02:00
|
|
|
int song;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
/*syncPlayerAndPlaylist(); */
|
2004-06-07 14:11:57 +02:00
|
|
|
playPlaylistIfPlayerStopped();
|
2006-07-20 18:02:40 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s: %i\n", COMMAND_STATUS_VOLUME, getVolumeLevel());
|
|
|
|
fdprintf(fd, "%s: %i\n", COMMAND_STATUS_REPEAT,
|
2006-08-26 08:25:44 +02:00
|
|
|
getPlaylistRepeatStatus());
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s: %i\n", COMMAND_STATUS_RANDOM,
|
2006-08-26 08:25:44 +02:00
|
|
|
getPlaylistRandomStatus());
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s: %li\n", COMMAND_STATUS_PLAYLIST,
|
2006-08-26 08:25:44 +02:00
|
|
|
getPlaylistVersion());
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s: %i\n", COMMAND_STATUS_PLAYLIST_LENGTH,
|
2006-08-26 08:25:44 +02:00
|
|
|
getPlaylistLength());
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s: %i\n", COMMAND_STATUS_CROSSFADE,
|
2006-08-26 08:25:44 +02:00
|
|
|
(int)(getPlayerCrossFade() + 0.5));
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s: %s\n", COMMAND_STATUS_STATE, state);
|
2006-07-20 18:02:40 +02:00
|
|
|
|
|
|
|
song = getPlaylistCurrentSong();
|
|
|
|
if (song >= 0) {
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s: %i\n", COMMAND_STATUS_SONG, song);
|
|
|
|
fdprintf(fd, "%s: %i\n", COMMAND_STATUS_SONGID,
|
2006-08-26 08:25:44 +02:00
|
|
|
getPlaylistSongId(song));
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
if (getPlayerState() != PLAYER_STATE_STOP) {
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s: %i:%i\n", COMMAND_STATUS_TIME,
|
2006-08-26 08:25:44 +02:00
|
|
|
getPlayerElapsedTime(), getPlayerTotalTime());
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s: %li\n", COMMAND_STATUS_BITRATE,
|
2006-08-26 08:25:44 +02:00
|
|
|
getPlayerBitRate());
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s: %u:%i:%i\n", COMMAND_STATUS_AUDIO,
|
2006-08-26 08:25:44 +02:00
|
|
|
getPlayerSampleRate(), getPlayerBits(),
|
|
|
|
getPlayerChannels());
|
2004-06-09 04:50:44 +02:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
|
|
|
|
if ((updateJobId = isUpdatingDB())) {
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s: %i\n", COMMAND_STATUS_UPDATING_DB,
|
2006-08-26 08:25:44 +02:00
|
|
|
updateJobId);
|
2004-04-11 05:12:00 +02:00
|
|
|
}
|
2004-04-11 04:34:26 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (getPlayerError() != PLAYER_ERROR_NOERROR) {
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "%s: %s\n", COMMAND_STATUS_ERROR,
|
2006-08-26 08:25:44 +02:00
|
|
|
getPlayerErrorStr());
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleKill(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
return COMMAND_RETURN_KILL;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleClose(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
return COMMAND_RETURN_CLOSE;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleAdd(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-29 20:54:56 +02:00
|
|
|
char *path = argv[1];
|
2005-05-03 04:35:19 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (isRemoteUrl(path))
|
2008-01-26 13:46:49 +01:00
|
|
|
return addToPlaylist(fd, path, NULL);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
return addAllIn(fd, path);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleAddId(int fd, int *permission, int argc, char *argv[])
|
2004-11-03 00:44:33 +01:00
|
|
|
{
|
2008-01-26 13:46:49 +01:00
|
|
|
int added_id;
|
|
|
|
int ret = addToPlaylist(fd, argv[1], &added_id);
|
|
|
|
|
2008-01-26 13:46:56 +01:00
|
|
|
if (!ret) {
|
|
|
|
if (argc == 3) {
|
|
|
|
int to;
|
|
|
|
if (check_int(fd, &to, argv[2],
|
|
|
|
check_integer, argv[2]) < 0)
|
|
|
|
return -1;
|
|
|
|
ret = moveSongInPlaylistById(fd, added_id, to);
|
|
|
|
if (ret) { /* move failed */
|
|
|
|
deleteFromPlaylistById(fd, added_id);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2008-01-26 13:46:49 +01:00
|
|
|
fdprintf(fd, "Id: %d\n", added_id);
|
2008-01-26 13:46:56 +01:00
|
|
|
}
|
2008-01-26 13:46:49 +01:00
|
|
|
return ret;
|
2004-11-03 00:44:33 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleDelete(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int song;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &song, argv[1], need_positive) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return deleteFromPlaylist(fd, song);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleDeleteId(int fd, int *permission, int argc, char *argv[])
|
2004-06-09 04:50:44 +02:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int id;
|
2004-06-09 04:50:44 +02:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &id, argv[1], need_positive) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return deleteFromPlaylistById(fd, id);
|
2004-06-09 04:50:44 +02:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handlePlaylist(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return showPlaylist(fd);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleShuffle(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return shufflePlaylist(fd);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleClear(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return clearPlaylist(fd);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleSave(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return savePlaylist(fd, argv[1]);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleLoad(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return loadPlaylist(fd, argv[1]);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2006-07-14 20:47:55 +02:00
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleListPlaylist(int fd, int *permission, int argc, char *argv[])
|
2006-03-26 15:46:05 +02:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return PlaylistInfo(fd, argv[1], 0);
|
2006-03-26 15:46:05 +02:00
|
|
|
}
|
2006-07-14 20:47:55 +02:00
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
static int handleListPlaylistInfo(int fd, int *permission,
|
|
|
|
int argc, char *argv[])
|
2006-03-26 15:46:05 +02:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return PlaylistInfo(fd, argv[1], 1);
|
2006-03-26 15:46:05 +02:00
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleLsInfo(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2007-05-24 19:06:59 +02:00
|
|
|
char *path = "";
|
|
|
|
|
|
|
|
if (argc == 2)
|
|
|
|
path = argv[1];
|
|
|
|
|
|
|
|
if (printDirectoryInfo(fd, path) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (isRootDirectory(path))
|
|
|
|
return lsPlaylists(fd, path);
|
|
|
|
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleRm(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return deletePlaylist(fd, argv[1]);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2007-05-24 20:07:19 +02:00
|
|
|
static int handleRename(int fd, int *permission, int argc, char *argv[])
|
|
|
|
{
|
|
|
|
return renameStoredPlaylist(fd, argv[1], argv[2]);
|
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
static int handlePlaylistChanges(int fd, int *permission,
|
|
|
|
int argc, char *argv[])
|
2004-06-05 03:14:37 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
mpd_uint32 version;
|
2004-06-05 03:14:37 +02:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_uint32(fd, &version, argv[1], need_positive) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return playlistChanges(fd, version);
|
2004-06-05 03:14:37 +02:00
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
static int handlePlaylistChangesPosId(int fd, int *permission,
|
|
|
|
int argc, char *argv[])
|
2006-04-23 13:10:41 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
mpd_uint32 version;
|
2006-04-23 13:10:41 +02:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_uint32(fd, &version, argv[1], need_positive) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return playlistChangesPosId(fd, version);
|
2006-04-23 13:10:41 +02:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handlePlaylistInfo(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int song = -1;
|
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (argc == 2 && check_int(fd, &song, argv[1], need_positive) < 0)
|
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return playlistInfo(fd, song);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handlePlaylistId(int fd, int *permission, int argc, char *argv[])
|
2004-06-09 04:50:44 +02:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int id = -1;
|
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (argc == 2 && check_int(fd, &id, argv[1], need_positive) < 0)
|
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return playlistId(fd, id);
|
2004-06-09 04:50:44 +02:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleFind(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2004-11-10 22:58:27 +01:00
|
|
|
int ret;
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
LocateTagItem *items;
|
2006-07-29 20:54:56 +02:00
|
|
|
int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
|
|
|
|
argc - 1,
|
2006-07-20 18:02:40 +02:00
|
|
|
&items);
|
2004-11-10 22:58:27 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (numItems <= 0) {
|
2006-07-30 10:47:50 +02:00
|
|
|
commandError(fd, ACK_ERROR_ARG, "incorrect arguments");
|
2004-11-10 22:58:27 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
ret = findSongsIn(fd, NULL, numItems, items);
|
2004-11-10 22:58:27 +01:00
|
|
|
|
2004-11-12 02:44:27 +01:00
|
|
|
freeLocateTagItemArray(numItems, items);
|
2004-11-10 22:58:27 +01:00
|
|
|
|
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleSearch(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2004-11-10 22:58:27 +01:00
|
|
|
int ret;
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
LocateTagItem *items;
|
2006-07-29 20:54:56 +02:00
|
|
|
int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
|
|
|
|
argc - 1,
|
2006-07-20 18:02:40 +02:00
|
|
|
&items);
|
2004-11-10 22:58:27 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (numItems <= 0) {
|
2006-07-30 10:47:50 +02:00
|
|
|
commandError(fd, ACK_ERROR_ARG, "incorrect arguments");
|
2004-11-10 22:58:27 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
ret = searchForSongsIn(fd, NULL, numItems, items);
|
2004-11-10 22:58:27 +01:00
|
|
|
|
2004-11-12 02:44:27 +01:00
|
|
|
freeLocateTagItemArray(numItems, items);
|
2004-11-10 22:58:27 +01:00
|
|
|
|
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2007-04-26 01:46:11 +02:00
|
|
|
static int handleCount(int fd, int *permission, int argc, char *argv[])
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
LocateTagItem *items;
|
|
|
|
int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
|
|
|
|
argc - 1,
|
|
|
|
&items);
|
|
|
|
|
|
|
|
if (numItems <= 0) {
|
|
|
|
commandError(fd, ACK_ERROR_ARG, "incorrect arguments");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = searchStatsForSongsIn(fd, NULL, numItems, items);
|
|
|
|
|
|
|
|
freeLocateTagItemArray(numItems, items);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-02-24 03:00:03 +01:00
|
|
|
static int handlePlaylistFind(int fd, int *permission, int argc, char *argv[])
|
|
|
|
{
|
|
|
|
LocateTagItem *items;
|
|
|
|
int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
|
|
|
|
argc - 1,
|
|
|
|
&items);
|
|
|
|
|
|
|
|
if (numItems <= 0) {
|
|
|
|
commandError(fd, ACK_ERROR_ARG, "incorrect arguments");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
findSongsInPlaylist(fd, numItems, items);
|
|
|
|
|
|
|
|
freeLocateTagItemArray(numItems, items);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handlePlaylistSearch(int fd, int *permission, int argc, char *argv[])
|
|
|
|
{
|
|
|
|
LocateTagItem *items;
|
|
|
|
int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
|
|
|
|
argc - 1,
|
|
|
|
&items);
|
|
|
|
|
|
|
|
if (numItems <= 0) {
|
|
|
|
commandError(fd, ACK_ERROR_ARG, "incorrect arguments");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
searchForSongsInPlaylist(fd, numItems, items);
|
|
|
|
|
|
|
|
freeLocateTagItemArray(numItems, items);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-05-16 14:02:10 +02:00
|
|
|
static int handlePlaylistDelete(int fd, int *permission, int argc, char *argv[]) {
|
|
|
|
char *playlist = argv[1];
|
|
|
|
int from;
|
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &from, argv[2], check_integer, argv[2]) < 0)
|
2007-05-16 14:02:10 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return removeOneSongFromStoredPlaylistByPath(fd, playlist, from);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handlePlaylistMove(int fd, int *permission, int argc, char *argv[])
|
|
|
|
{
|
|
|
|
char *playlist = argv[1];
|
|
|
|
int from, to;
|
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &from, argv[2], check_integer, argv[2]) < 0)
|
2007-05-16 14:02:10 +02:00
|
|
|
return -1;
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &to, argv[3], check_integer, argv[3]) < 0)
|
2007-05-16 14:02:10 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return moveSongInStoredPlaylistByPath(fd, playlist, from, to);
|
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
static int listHandleUpdate(int fd,
|
2006-07-20 18:02:40 +02:00
|
|
|
int *permission,
|
2006-07-29 20:54:56 +02:00
|
|
|
int argc,
|
2006-07-30 05:43:38 +02:00
|
|
|
char *argv[],
|
2006-08-26 08:25:44 +02:00
|
|
|
struct strnode *cmdnode, CommandEntry * cmd)
|
2004-04-11 19:37:47 +02:00
|
|
|
{
|
2007-01-14 04:07:53 +01:00
|
|
|
static List *pathList;
|
2006-07-20 18:02:40 +02:00
|
|
|
CommandEntry *nextCmd = NULL;
|
2006-07-30 05:43:38 +02:00
|
|
|
struct strnode *next = cmdnode->next;
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (!pathList)
|
|
|
|
pathList = makeList(NULL, 1);
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2006-07-29 20:54:56 +02:00
|
|
|
if (argc == 2)
|
|
|
|
insertInList(pathList, argv[1], NULL);
|
2006-07-20 18:02:40 +02:00
|
|
|
else
|
|
|
|
insertInList(pathList, "", NULL);
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
if (next)
|
2006-07-30 05:43:38 +02:00
|
|
|
nextCmd = getCommandEntryFromString(next->data, permission);
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (cmd != nextCmd) {
|
2006-07-30 05:43:38 +02:00
|
|
|
int ret = updateInit(fd, pathList);
|
2004-04-11 19:37:47 +02:00
|
|
|
freeList(pathList);
|
|
|
|
pathList = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleUpdate(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-29 20:54:56 +02:00
|
|
|
if (argc == 2) {
|
2004-04-11 19:37:47 +02:00
|
|
|
int ret;
|
2006-07-20 18:02:40 +02:00
|
|
|
List *pathList = makeList(NULL, 1);
|
2006-07-29 20:54:56 +02:00
|
|
|
insertInList(pathList, argv[1], NULL);
|
2006-07-30 05:43:38 +02:00
|
|
|
ret = updateInit(fd, pathList);
|
2004-04-11 19:37:47 +02:00
|
|
|
freeList(pathList);
|
|
|
|
return ret;
|
|
|
|
}
|
2006-07-30 05:43:38 +02:00
|
|
|
return updateInit(fd, NULL);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleNext(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return nextSongInPlaylist(fd);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handlePrevious(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return previousSongInPlaylist(fd);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleListAll(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
char *directory = NULL;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-29 20:54:56 +02:00
|
|
|
if (argc == 2)
|
|
|
|
directory = argv[1];
|
2006-07-30 05:43:38 +02:00
|
|
|
return printAllIn(fd, directory);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleVolume(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int change;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &change, argv[1], need_integer) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return changeVolumeLevel(fd, change, 1);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleSetVol(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int level;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &level, argv[1], need_integer) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return changeVolumeLevel(fd, level, 0);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleRepeat(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int status;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &status, argv[1], need_integer) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return setPlaylistRepeatStatus(fd, status);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleRandom(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int status;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &status, argv[1], need_integer) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return setPlaylistRandomStatus(fd, status);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleStats(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return printStats(fd);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleClearError(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
clearPlayerError();
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleList(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2004-11-10 22:58:27 +01:00
|
|
|
int numConditionals = 0;
|
2006-07-20 18:02:40 +02:00
|
|
|
LocateTagItem *conditionals = NULL;
|
2006-07-29 20:54:56 +02:00
|
|
|
int tagType = getLocateTagItemType(argv[1]);
|
2004-11-10 22:58:27 +01:00
|
|
|
int ret;
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (tagType < 0) {
|
2006-08-26 08:25:44 +02:00
|
|
|
commandError(fd, ACK_ERROR_ARG, "\"%s\" is not known", argv[1]);
|
2004-11-10 22:58:27 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-12-11 21:18:04 +01:00
|
|
|
if (tagType == LOCATE_TAG_ANY_TYPE) {
|
|
|
|
commandError(fd, ACK_ERROR_ARG,
|
|
|
|
"\"any\" is not a valid return tag type");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2004-11-10 22:58:27 +01:00
|
|
|
/* for compatibility with < 0.12.0 */
|
2006-07-29 20:54:56 +02:00
|
|
|
if (argc == 3) {
|
2006-07-20 18:02:40 +02:00
|
|
|
if (tagType != TAG_ITEM_ALBUM) {
|
2006-07-30 05:43:38 +02:00
|
|
|
commandError(fd, ACK_ERROR_ARG,
|
2006-07-20 18:02:40 +02:00
|
|
|
"should be \"%s\" for 3 arguments",
|
|
|
|
mpdTagItemKeys[TAG_ITEM_ALBUM]);
|
2004-11-10 22:58:27 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
conditionals = newLocateTagItem(mpdTagItemKeys[TAG_ITEM_ARTIST],
|
2006-07-29 20:54:56 +02:00
|
|
|
argv[2]);
|
2004-11-10 22:58:27 +01:00
|
|
|
numConditionals = 1;
|
2006-07-20 18:02:40 +02:00
|
|
|
} else {
|
|
|
|
numConditionals =
|
2006-07-29 20:54:56 +02:00
|
|
|
newLocateTagItemArrayFromArgArray(argv + 2,
|
2006-08-26 08:25:44 +02:00
|
|
|
argc - 2, &conditionals);
|
2006-07-20 18:02:40 +02:00
|
|
|
|
|
|
|
if (numConditionals < 0) {
|
2006-07-30 05:43:38 +02:00
|
|
|
commandError(fd, ACK_ERROR_ARG,
|
2006-07-30 10:47:50 +02:00
|
|
|
"not able to parse args");
|
2004-11-12 02:44:27 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2006-07-14 20:47:55 +02:00
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
ret = listAllUniqueTags(fd, tagType, numConditionals, conditionals);
|
2004-11-10 22:58:27 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (conditionals)
|
|
|
|
freeLocateTagItemArray(numConditionals, conditionals);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-11-10 22:58:27 +01:00
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleMove(int fd, int *permission, int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
int from, to;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &from, argv[1], check_integer, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &to, argv[2], check_integer, argv[2]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return moveSongInPlaylist(fd, from, to);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleMoveId(int fd, int *permission, int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
int id, to;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &id, argv[1], check_integer, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &to, argv[2], check_integer, argv[2]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return moveSongInPlaylistById(fd, id, to);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleSwap(int fd, int *permission, int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
int song1, song2;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &song1, argv[1], check_integer, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &song2, argv[2], check_integer, argv[2]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return swapSongsInPlaylist(fd, song1, song2);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleSwapId(int fd, int *permission, int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
int id1, id2;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &id1, argv[1], check_integer, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &id2, argv[2], check_integer, argv[2]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return swapSongsInPlaylistById(fd, id1, id2);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleSeek(int fd, int *permission, int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
int song, seek_time;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &song, argv[1], check_integer, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &seek_time, argv[2], check_integer, argv[2]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-01-26 13:46:21 +01:00
|
|
|
return seekSongInPlaylist(fd, song, seek_time);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleSeekId(int fd, int *permission, int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
int id, seek_time;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &id, argv[1], check_integer, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &seek_time, argv[2], check_integer, argv[2]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-01-26 13:46:21 +01:00
|
|
|
return seekSongInPlaylistById(fd, id, seek_time);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleListAllInfo(int fd, int *permission, int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
|
|
|
char *directory = NULL;
|
|
|
|
|
2006-07-29 20:54:56 +02:00
|
|
|
if (argc == 2)
|
|
|
|
directory = argv[1];
|
2006-07-30 05:43:38 +02:00
|
|
|
return printInfoForAllIn(fd, directory);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handlePing(int fd, int *permission, int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handlePassword(int fd, int *permission, int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2006-07-29 20:54:56 +02:00
|
|
|
if (getPermissionFromPassword(argv[1], permission) < 0) {
|
2006-07-30 10:47:50 +02:00
|
|
|
commandError(fd, ACK_ERROR_PASSWORD, "incorrect password");
|
2004-02-24 00:41:20 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleCrossfade(int fd, int *permission, int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-01-26 13:46:21 +01:00
|
|
|
int xfade_time;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &xfade_time, argv[1], check_non_negative, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-01-26 13:46:21 +01:00
|
|
|
setPlayerCrossFade(xfade_time);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleEnableDevice(int fd, int *permission, int argc, char *argv[])
|
2004-11-02 23:13:58 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int device;
|
2004-11-02 23:13:58 +01:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &device, argv[1], check_non_negative, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return enableAudioDevice(fd, device);
|
2004-11-02 23:13:58 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleDisableDevice(int fd, int *permission, int argc, char *argv[])
|
2004-11-02 23:13:58 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int device;
|
2004-11-02 23:13:58 +01:00
|
|
|
|
2008-01-26 13:46:53 +01:00
|
|
|
if (check_int(fd, &device, argv[1], check_non_negative, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2006-07-30 05:43:38 +02:00
|
|
|
return disableAudioDevice(fd, device);
|
2004-11-02 23:13:58 +01:00
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleDevices(int fd, int *permission, int argc, char *argv[])
|
2004-11-03 00:08:00 +01:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
printAudioDevices(fd);
|
2004-11-03 00:08:00 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-11-08 19:01:36 +01:00
|
|
|
/* don't be fooled, this is the command handler for "commands" command */
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleCommands(int fd, int *permission, int argc, char *argv[])
|
2004-11-08 19:01:36 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
ListNode *node = commandList->firstNode;
|
|
|
|
CommandEntry *cmd;
|
2004-11-08 19:01:36 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (node != NULL) {
|
2004-11-08 19:01:36 +01:00
|
|
|
cmd = (CommandEntry *) node->data;
|
2006-07-20 18:02:40 +02:00
|
|
|
if (cmd->reqPermission == (*permission & cmd->reqPermission)) {
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "command: %s\n", cmd->cmd);
|
2004-11-08 19:01:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
static int handleNotcommands(int fd, int *permission, int argc, char *argv[])
|
2004-11-23 20:46:33 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
ListNode *node = commandList->firstNode;
|
|
|
|
CommandEntry *cmd;
|
2004-11-23 20:46:33 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
while (node != NULL) {
|
2004-11-23 20:46:33 +01:00
|
|
|
cmd = (CommandEntry *) node->data;
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (cmd->reqPermission != (*permission & cmd->reqPermission)) {
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "command: %s\n", cmd->cmd);
|
2004-11-23 20:46:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-12-07 15:41:40 +01:00
|
|
|
static int handlePlaylistClear(int fd, int *permission, int argc, char *argv[])
|
|
|
|
{
|
|
|
|
return clearStoredPlaylist(fd, argv[1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int handlePlaylistAdd(int fd, int *permission, int argc, char *argv[])
|
|
|
|
{
|
|
|
|
char *playlist = argv[1];
|
|
|
|
char *path = argv[2];
|
|
|
|
|
|
|
|
if (isRemoteUrl(path))
|
|
|
|
return addToStoredPlaylist(fd, path, playlist);
|
|
|
|
|
|
|
|
return addAllInToStoredPlaylist(fd, path, playlist);
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
void initCommands(void)
|
|
|
|
{
|
|
|
|
commandList = makeList(free, 1);
|
|
|
|
|
2006-08-07 17:46:35 +02:00
|
|
|
/* addCommand(name, permission, min, max, handler, list handler); */
|
|
|
|
addCommand(COMMAND_PLAY, PERMISSION_CONTROL, 0, 1, handlePlay, NULL);
|
|
|
|
addCommand(COMMAND_PLAYID, PERMISSION_CONTROL, 0, 1, handlePlayId, NULL);
|
|
|
|
addCommand(COMMAND_STOP, PERMISSION_CONTROL, 0, 0, handleStop, NULL);
|
|
|
|
addCommand(COMMAND_CURRENTSONG, PERMISSION_READ, 0, 0, handleCurrentSong, NULL);
|
|
|
|
addCommand(COMMAND_PAUSE, PERMISSION_CONTROL, 0, 1, handlePause, NULL);
|
|
|
|
addCommand(COMMAND_STATUS, PERMISSION_READ, 0, 0, commandStatus, NULL);
|
|
|
|
addCommand(COMMAND_KILL, PERMISSION_ADMIN, -1, -1, handleKill, NULL);
|
2006-08-07 17:48:16 +02:00
|
|
|
addCommand(COMMAND_CLOSE, PERMISSION_NONE, -1, -1, handleClose, NULL);
|
2006-08-07 17:46:35 +02:00
|
|
|
addCommand(COMMAND_ADD, PERMISSION_ADD, 1, 1, handleAdd, NULL);
|
2008-01-26 13:46:56 +01:00
|
|
|
addCommand(COMMAND_ADDID, PERMISSION_ADD, 1, 2, handleAddId, NULL);
|
2006-08-07 17:46:35 +02:00
|
|
|
addCommand(COMMAND_DELETE, PERMISSION_CONTROL, 1, 1, handleDelete, NULL);
|
|
|
|
addCommand(COMMAND_DELETEID, PERMISSION_CONTROL, 1, 1, handleDeleteId, NULL);
|
|
|
|
addCommand(COMMAND_PLAYLIST, PERMISSION_READ, 0, 0, handlePlaylist, NULL);
|
|
|
|
addCommand(COMMAND_PLAYLISTID, PERMISSION_READ, 0, 1, handlePlaylistId, NULL);
|
|
|
|
addCommand(COMMAND_SHUFFLE, PERMISSION_CONTROL, 0, 0, handleShuffle, NULL);
|
|
|
|
addCommand(COMMAND_CLEAR, PERMISSION_CONTROL, 0, 0, handleClear, NULL);
|
|
|
|
addCommand(COMMAND_SAVE, PERMISSION_CONTROL, 1, 1, handleSave, NULL);
|
|
|
|
addCommand(COMMAND_LOAD, PERMISSION_ADD, 1, 1, handleLoad, NULL);
|
|
|
|
addCommand(COMMAND_LISTPLAYLIST, PERMISSION_READ, 1, 1, handleListPlaylist, NULL);
|
|
|
|
addCommand(COMMAND_LISTPLAYLISTINFO, PERMISSION_READ, 1, 1, handleListPlaylistInfo, NULL);
|
|
|
|
addCommand(COMMAND_LSINFO, PERMISSION_READ, 0, 1, handleLsInfo, NULL);
|
|
|
|
addCommand(COMMAND_RM, PERMISSION_CONTROL, 1, 1, handleRm, NULL);
|
|
|
|
addCommand(COMMAND_PLAYLISTINFO, PERMISSION_READ, 0, 1, handlePlaylistInfo, NULL);
|
|
|
|
addCommand(COMMAND_FIND, PERMISSION_READ, 2, -1, handleFind, NULL);
|
|
|
|
addCommand(COMMAND_SEARCH, PERMISSION_READ, 2, -1, handleSearch, NULL);
|
|
|
|
addCommand(COMMAND_UPDATE, PERMISSION_ADMIN, 0, 1, handleUpdate, listHandleUpdate);
|
|
|
|
addCommand(COMMAND_NEXT, PERMISSION_CONTROL, 0, 0, handleNext, NULL);
|
|
|
|
addCommand(COMMAND_PREVIOUS, PERMISSION_CONTROL, 0, 0, handlePrevious, NULL);
|
|
|
|
addCommand(COMMAND_LISTALL, PERMISSION_READ, 0, 1, handleListAll, NULL);
|
|
|
|
addCommand(COMMAND_VOLUME, PERMISSION_CONTROL, 1, 1, handleVolume, NULL);
|
|
|
|
addCommand(COMMAND_REPEAT, PERMISSION_CONTROL, 1, 1, handleRepeat, NULL);
|
|
|
|
addCommand(COMMAND_RANDOM, PERMISSION_CONTROL, 1, 1, handleRandom, NULL);
|
|
|
|
addCommand(COMMAND_STATS, PERMISSION_READ, 0, 0, handleStats, NULL);
|
|
|
|
addCommand(COMMAND_CLEAR_ERROR, PERMISSION_CONTROL, 0, 0, handleClearError, NULL);
|
|
|
|
addCommand(COMMAND_LIST, PERMISSION_READ, 1, -1, handleList, NULL);
|
|
|
|
addCommand(COMMAND_MOVE, PERMISSION_CONTROL, 2, 2, handleMove, NULL);
|
|
|
|
addCommand(COMMAND_MOVEID, PERMISSION_CONTROL, 2, 2, handleMoveId, NULL);
|
|
|
|
addCommand(COMMAND_SWAP, PERMISSION_CONTROL, 2, 2, handleSwap, NULL);
|
|
|
|
addCommand(COMMAND_SWAPID, PERMISSION_CONTROL, 2, 2, handleSwapId, NULL);
|
|
|
|
addCommand(COMMAND_SEEK, PERMISSION_CONTROL, 2, 2, handleSeek, NULL);
|
|
|
|
addCommand(COMMAND_SEEKID, PERMISSION_CONTROL, 2, 2, handleSeekId, NULL);
|
|
|
|
addCommand(COMMAND_LISTALLINFO, PERMISSION_READ, 0, 1, handleListAllInfo, NULL);
|
2006-08-07 17:48:16 +02:00
|
|
|
addCommand(COMMAND_PING, PERMISSION_NONE, 0, 0, handlePing, NULL);
|
2006-08-07 17:46:35 +02:00
|
|
|
addCommand(COMMAND_SETVOL, PERMISSION_CONTROL, 1, 1, handleSetVol, NULL);
|
2006-08-07 17:48:16 +02:00
|
|
|
addCommand(COMMAND_PASSWORD, PERMISSION_NONE, 1, 1, handlePassword, NULL);
|
2006-08-07 17:46:35 +02:00
|
|
|
addCommand(COMMAND_CROSSFADE, PERMISSION_CONTROL, 1, 1, handleCrossfade, NULL);
|
|
|
|
addCommand(COMMAND_URL_HANDLERS, PERMISSION_READ, 0, 0, handleUrlHandlers, NULL);
|
|
|
|
addCommand(COMMAND_PLCHANGES, PERMISSION_READ, 1, 1, handlePlaylistChanges, NULL);
|
|
|
|
addCommand(COMMAND_PLCHANGESPOSID, PERMISSION_READ, 1, 1, handlePlaylistChangesPosId, NULL);
|
|
|
|
addCommand(COMMAND_ENABLE_DEV, PERMISSION_ADMIN, 1, 1, handleEnableDevice, NULL);
|
|
|
|
addCommand(COMMAND_DISABLE_DEV, PERMISSION_ADMIN, 1, 1, handleDisableDevice, NULL);
|
|
|
|
addCommand(COMMAND_DEVICES, PERMISSION_READ, 0, 0, handleDevices, NULL);
|
2006-08-07 17:48:16 +02:00
|
|
|
addCommand(COMMAND_COMMANDS, PERMISSION_NONE, 0, 0, handleCommands, NULL);
|
|
|
|
addCommand(COMMAND_NOTCOMMANDS, PERMISSION_NONE, 0, 0, handleNotcommands, NULL);
|
2006-12-07 15:41:40 +01:00
|
|
|
addCommand(COMMAND_PLAYLISTCLEAR, PERMISSION_CONTROL, 1, 1, handlePlaylistClear, NULL);
|
|
|
|
addCommand(COMMAND_PLAYLISTADD, PERMISSION_CONTROL, 2, 2, handlePlaylistAdd, NULL);
|
2007-02-24 03:00:03 +01:00
|
|
|
addCommand(COMMAND_PLAYLISTFIND, PERMISSION_READ, 2, -1, handlePlaylistFind, NULL);
|
|
|
|
addCommand(COMMAND_PLAYLISTSEARCH, PERMISSION_READ, 2, -1, handlePlaylistSearch, NULL);
|
2007-05-16 14:02:10 +02:00
|
|
|
addCommand(COMMAND_PLAYLISTMOVE, PERMISSION_CONTROL, 3, 3, handlePlaylistMove, NULL);
|
|
|
|
addCommand(COMMAND_PLAYLISTDELETE, PERMISSION_CONTROL, 2, 2, handlePlaylistDelete, NULL);
|
2007-03-31 20:43:16 +02:00
|
|
|
addCommand(COMMAND_TAGTYPES, PERMISSION_READ, 0, 0, handleTagTypes, NULL);
|
2007-04-26 01:46:11 +02:00
|
|
|
addCommand(COMMAND_COUNT, PERMISSION_READ, 2, -1, handleCount, NULL);
|
2007-05-24 20:07:19 +02:00
|
|
|
addCommand(COMMAND_RENAME, PERMISSION_CONTROL, 2, 2, handleRename, NULL);
|
2006-07-20 18:02:40 +02:00
|
|
|
|
|
|
|
sortList(commandList);
|
|
|
|
}
|
|
|
|
|
|
|
|
void finishCommands(void)
|
|
|
|
{
|
|
|
|
freeList(commandList);
|
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
static int checkArgcAndPermission(CommandEntry * cmd, int fd,
|
|
|
|
int permission, int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
|
|
|
int min = cmd->min + 1;
|
|
|
|
int max = cmd->max + 1;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
|
|
|
if (cmd->reqPermission != (permission & cmd->reqPermission)) {
|
2006-07-30 05:43:38 +02:00
|
|
|
if (fd) {
|
|
|
|
commandError(fd, ACK_ERROR_PERMISSION,
|
2006-07-20 18:02:40 +02:00
|
|
|
"you don't have permission for \"%s\"",
|
|
|
|
cmd->cmd);
|
2004-04-11 19:37:47 +02:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (min == 0)
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (min == max && max != argc) {
|
2006-07-30 05:43:38 +02:00
|
|
|
if (fd) {
|
|
|
|
commandError(fd, ACK_ERROR_ARG,
|
2006-07-20 18:02:40 +02:00
|
|
|
"wrong number of arguments for \"%s\"",
|
2006-07-29 20:54:56 +02:00
|
|
|
argv[0]);
|
2004-04-11 19:37:47 +02:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
|
|
|
} else if (argc < min) {
|
2006-07-30 05:43:38 +02:00
|
|
|
if (fd) {
|
|
|
|
commandError(fd, ACK_ERROR_ARG,
|
2006-08-26 08:25:44 +02:00
|
|
|
"too few arguments for \"%s\"", argv[0]);
|
2004-04-11 19:37:47 +02:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
|
|
|
} else if (argc > max && max /* != 0 */ ) {
|
2006-07-30 05:43:38 +02:00
|
|
|
if (fd) {
|
|
|
|
commandError(fd, ACK_ERROR_ARG,
|
2006-08-26 08:25:44 +02:00
|
|
|
"too many arguments for \"%s\"", argv[0]);
|
2004-04-11 19:37:47 +02:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
|
|
|
} else
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
static CommandEntry *getCommandEntryAndCheckArgcAndPermission(int fd,
|
2006-07-20 18:02:40 +02:00
|
|
|
int *permission,
|
2006-07-30 05:43:38 +02:00
|
|
|
int argc,
|
|
|
|
char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2004-06-04 03:58:31 +02:00
|
|
|
static char unknown[] = "";
|
2006-07-20 18:02:40 +02:00
|
|
|
CommandEntry *cmd;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-06-04 03:58:31 +02:00
|
|
|
current_command = unknown;
|
|
|
|
|
2006-07-29 20:54:56 +02:00
|
|
|
if (argc == 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return NULL;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-29 20:54:56 +02:00
|
|
|
if (!findInList(commandList, argv[0], (void *)&cmd)) {
|
2006-07-30 05:43:38 +02:00
|
|
|
if (fd) {
|
|
|
|
commandError(fd, ACK_ERROR_UNKNOWN,
|
2006-07-29 20:54:56 +02:00
|
|
|
"unknown command \"%s\"", argv[0]);
|
2004-06-04 04:51:54 +02:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2004-06-04 03:58:31 +02:00
|
|
|
current_command = cmd->cmd;
|
|
|
|
|
2006-08-26 08:25:44 +02:00
|
|
|
if (checkArgcAndPermission(cmd, fd, *permission, argc, argv) < 0) {
|
2004-04-11 19:37:47 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cmd;
|
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
static CommandEntry *getCommandEntryFromString(char *string, int *permission)
|
|
|
|
{
|
|
|
|
CommandEntry *cmd = NULL;
|
2006-10-06 12:33:27 +02:00
|
|
|
char *argv[COMMAND_ARGV_MAX] = { NULL };
|
|
|
|
int argc = buffer2array(string, argv, COMMAND_ARGV_MAX);
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2006-07-29 20:54:56 +02:00
|
|
|
if (0 == argc)
|
2006-07-20 18:02:40 +02:00
|
|
|
return NULL;
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
cmd = getCommandEntryAndCheckArgcAndPermission(0, permission,
|
2006-07-29 20:55:00 +02:00
|
|
|
argc, argv);
|
2004-04-11 19:37:47 +02:00
|
|
|
|
|
|
|
return cmd;
|
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
static int processCommandInternal(int fd, int *permission,
|
2006-10-06 12:33:27 +02:00
|
|
|
char *commandString, struct strnode *cmdnode)
|
2004-04-11 19:37:47 +02:00
|
|
|
{
|
2006-10-06 12:33:27 +02:00
|
|
|
int argc;
|
|
|
|
char *argv[COMMAND_ARGV_MAX] = { NULL };
|
2006-07-20 18:02:40 +02:00
|
|
|
CommandEntry *cmd;
|
2004-04-12 03:44:52 +02:00
|
|
|
int ret = -1;
|
|
|
|
|
2006-10-06 12:33:27 +02:00
|
|
|
argc = buffer2array(commandString, argv, COMMAND_ARGV_MAX);
|
|
|
|
|
2006-07-29 20:54:56 +02:00
|
|
|
if (argc == 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return 0;
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
if ((cmd = getCommandEntryAndCheckArgcAndPermission(fd, permission,
|
2006-07-29 20:55:00 +02:00
|
|
|
argc, argv))) {
|
2006-07-30 05:43:38 +02:00
|
|
|
if (!cmdnode || !cmd->listHandler) {
|
|
|
|
ret = cmd->handler(fd, permission, argc, argv);
|
2006-07-20 18:02:40 +02:00
|
|
|
} else {
|
2006-07-30 05:43:38 +02:00
|
|
|
ret = cmd->listHandler(fd, permission, argc, argv,
|
2006-08-26 08:25:44 +02:00
|
|
|
cmdnode, cmd);
|
2004-04-12 03:44:52 +02:00
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2004-06-04 03:58:31 +02:00
|
|
|
current_command = NULL;
|
|
|
|
|
2004-04-12 03:44:52 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
int processListOfCommands(int fd, int *permission, int *expired,
|
|
|
|
int listOK, struct strnode *list)
|
2004-04-12 03:44:52 +02:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
struct strnode *cur = list;
|
2004-04-12 03:44:52 +02:00
|
|
|
int ret = 0;
|
|
|
|
|
2004-06-04 03:58:31 +02:00
|
|
|
command_listNum = 0;
|
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
while (cur) {
|
2006-07-14 20:47:55 +02:00
|
|
|
DEBUG("processListOfCommands: process command \"%s\"\n",
|
2006-07-30 05:43:38 +02:00
|
|
|
cur->data);
|
|
|
|
ret = processCommandInternal(fd, permission, cur->data, cur);
|
2006-07-20 18:02:40 +02:00
|
|
|
DEBUG("processListOfCommands: command returned %i\n", ret);
|
|
|
|
if (ret != 0 || (*expired) != 0)
|
2006-07-30 05:43:38 +02:00
|
|
|
goto out;
|
2006-07-20 18:02:40 +02:00
|
|
|
else if (listOK)
|
2006-07-30 05:43:38 +02:00
|
|
|
fdprintf(fd, "list_OK\n");
|
2004-06-04 03:58:31 +02:00
|
|
|
command_listNum++;
|
2006-07-30 05:43:38 +02:00
|
|
|
cur = cur->next;
|
2004-04-11 19:37:47 +02:00
|
|
|
}
|
2006-07-30 05:43:38 +02:00
|
|
|
out:
|
2004-06-04 03:58:31 +02:00
|
|
|
command_listNum = 0;
|
2004-04-12 03:44:52 +02:00
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
int processCommand(int fd, int *permission, char *commandString)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2006-07-30 05:43:38 +02:00
|
|
|
return processCommandInternal(fd, permission, commandString, NULL);
|
2004-04-12 03:44:52 +02:00
|
|
|
}
|
2006-07-30 10:47:50 +02:00
|
|
|
|
|
|
|
mpd_fprintf_ void commandError(int fd, int error, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
va_start(args, fmt);
|
2008-01-26 13:46:53 +01:00
|
|
|
command_error_va(fd, error, fmt, args);
|
2006-07-30 10:47:50 +02:00
|
|
|
va_end(args);
|
|
|
|
}
|