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"
|
2008-08-26 08:44:38 +02:00
|
|
|
#include "player_control.h"
|
2004-02-24 00:41:20 +01:00
|
|
|
#include "playlist.h"
|
|
|
|
#include "ls.h"
|
|
|
|
#include "directory.h"
|
2008-10-09 15:23:37 +02:00
|
|
|
#include "directory_print.h"
|
2008-10-08 11:07:35 +02:00
|
|
|
#include "database.h"
|
2008-10-08 10:48:48 +02:00
|
|
|
#include "update.h"
|
2004-02-24 00:41:20 +01:00
|
|
|
#include "volume.h"
|
|
|
|
#include "stats.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-08-26 08:25:57 +02:00
|
|
|
#include "utils.h"
|
2007-05-16 14:02:10 +02:00
|
|
|
#include "storedPlaylist.h"
|
2008-04-12 06:19:26 +02:00
|
|
|
#include "sllist.h"
|
|
|
|
#include "ack.h"
|
2008-08-26 08:27:06 +02:00
|
|
|
#include "audio.h"
|
2008-08-28 20:01:08 +02:00
|
|
|
#include "dbUtils.h"
|
2008-09-06 20:28:31 +02:00
|
|
|
#include "tag.h"
|
2008-08-29 09:36:42 +02:00
|
|
|
#include "client.h"
|
2008-09-07 13:28:01 +02:00
|
|
|
#include "tag_print.h"
|
2008-10-06 18:32:27 +02:00
|
|
|
#include "path.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;
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
typedef int (*CommandHandlerFunction) (struct client *, int, char **);
|
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 {
|
2008-02-05 11:17:33 +01:00
|
|
|
const char *cmd;
|
2006-07-20 18:02:40 +02:00
|
|
|
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
|
|
|
};
|
|
|
|
|
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";
|
|
|
|
|
2008-02-05 11:17:33 +01:00
|
|
|
static const char *current_command;
|
2007-01-14 04:07:53 +01:00
|
|
|
static int command_listNum;
|
2004-06-04 03:58:31 +02:00
|
|
|
|
2006-07-30 05:43:38 +02:00
|
|
|
static List *commandList;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2008-09-07 13:51:59 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2008-09-29 15:49:29 +02:00
|
|
|
static int mpd_fprintf__ check_uint32(struct client *client, uint32_t *dst,
|
2008-01-26 13:46:53 +01:00
|
|
|
const char *s, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
char *test;
|
|
|
|
|
|
|
|
*dst = strtoul(s, &test, 10);
|
|
|
|
if (*test != '\0') {
|
|
|
|
va_list args;
|
|
|
|
va_start(args, fmt);
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error_v(client, ACK_ERROR_ARG, fmt, args);
|
2008-01-26 13:46:53 +01:00
|
|
|
va_end(args);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
static int mpd_fprintf__ check_int(struct client *client, int *dst,
|
2008-01-26 13:46:53 +01:00
|
|
|
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);
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error_v(client, ACK_ERROR_ARG, fmt, args);
|
2008-01-26 13:46:53 +01:00
|
|
|
va_end(args);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
static int print_playlist_result(struct client *client,
|
|
|
|
enum playlist_result result)
|
2008-09-07 13:39:31 +02:00
|
|
|
{
|
|
|
|
switch (result) {
|
|
|
|
case PLAYLIST_RESULT_SUCCESS:
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case PLAYLIST_RESULT_ERRNO:
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_SYSTEM, strerror(errno));
|
2008-09-07 13:39:31 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
case PLAYLIST_RESULT_NO_SUCH_SONG:
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST, "No such song");
|
2008-09-07 13:39:31 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
case PLAYLIST_RESULT_NO_SUCH_LIST:
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST, "No such playlist");
|
2008-09-07 13:39:31 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
case PLAYLIST_RESULT_LIST_EXISTS:
|
2008-10-09 11:51:22 +02:00
|
|
|
command_error(client, ACK_ERROR_EXIST,
|
2008-09-07 13:52:48 +02:00
|
|
|
"Playlist already exists");
|
2008-09-07 13:39:31 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
case PLAYLIST_RESULT_BAD_NAME:
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_ARG,
|
|
|
|
"playlist name is invalid: "
|
|
|
|
"playlist names may not contain slashes,"
|
|
|
|
" newlines or carriage returns");
|
2008-09-07 13:39:31 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
case PLAYLIST_RESULT_BAD_RANGE:
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_ARG, "Bad song index");
|
2008-09-07 13:39:31 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
case PLAYLIST_RESULT_NOT_PLAYING:
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_PLAYER_SYNC, "Not playing");
|
2008-09-07 13:39:31 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
case PLAYLIST_RESULT_TOO_LARGE:
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_PLAYLIST_MAX,
|
|
|
|
"playlist is at the max size");
|
2008-09-07 13:39:31 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(0);
|
2008-09-07 19:19:48 +02:00
|
|
|
return -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
}
|
|
|
|
|
2008-02-05 11:17:33 +01:00
|
|
|
static void addCommand(const char *name,
|
2006-07-20 18:02:40 +02:00
|
|
|
int reqPermission,
|
2006-07-17 23:46:32 +02:00
|
|
|
int minargs,
|
2006-07-20 18:02:40 +02:00
|
|
|
int maxargs,
|
2008-10-06 18:34:18 +02:00
|
|
|
CommandHandlerFunction handler_func)
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-10-06 18:34:18 +02:00
|
|
|
CommandEntry *cmd = xmalloc(sizeof(CommandEntry));
|
2006-07-20 18:02:40 +02:00
|
|
|
cmd->cmd = name;
|
|
|
|
cmd->min = minargs;
|
|
|
|
cmd->max = maxargs;
|
|
|
|
cmd->handler = handler_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
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleUrlHandlers(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-06-03 01:22:37 +02:00
|
|
|
{
|
2008-09-07 14:02:40 +02:00
|
|
|
return printRemoteUrlHandlers(client);
|
2004-06-03 01:22:37 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleTagTypes(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2007-03-31 20:43:16 +02:00
|
|
|
{
|
2008-09-07 13:53:55 +02:00
|
|
|
tag_print_types(client);
|
2007-03-31 20:43:16 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlay(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int song = -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (argc == 2 && check_int(client, &song, argv[1], need_positive) < 0)
|
2008-01-26 13:46:53 +01:00
|
|
|
return -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
result = playPlaylist(song, 0);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlayId(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
int argc, char *argv[])
|
2004-06-09 04:50:44 +02:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int id = -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (argc == 2 && check_int(client, &id, argv[1], need_positive) < 0)
|
2008-01-26 13:46:53 +01:00
|
|
|
return -1;
|
|
|
|
|
2008-09-07 13:39:31 +02:00
|
|
|
result = playPlaylistById(id, 0);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2004-06-09 04:50:44 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleStop(mpd_unused struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-08-26 08:27:16 +02:00
|
|
|
stopPlaylist();
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleCurrentSong(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-06-10 06:13:23 +02:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int song = getPlaylistCurrentSong();
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2004-06-10 06:13:23 +02:00
|
|
|
|
2008-09-07 13:39:31 +02:00
|
|
|
if (song < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return 0;
|
2008-09-07 13:39:31 +02:00
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
result = playlistInfo(client, song);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2004-06-10 06:13:23 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePause(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
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;
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &pause_flag, argv[1], check_boolean, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-08-26 08:27:16 +02:00
|
|
|
playerSetPause(pause_flag);
|
|
|
|
return 0;
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
2008-08-26 08:27:16 +02:00
|
|
|
|
|
|
|
playerPause();
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int commandStatus(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-02-05 11:17:33 +01:00
|
|
|
const 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
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
client_printf(client,
|
2008-09-07 13:57:43 +02:00
|
|
|
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(),
|
2008-09-07 13:52:48 +02:00
|
|
|
(int)(getPlayerCrossFade() + 0.5),
|
2008-09-07 13:57:43 +02:00
|
|
|
state);
|
2006-07-20 18:02:40 +02:00
|
|
|
|
|
|
|
song = getPlaylistCurrentSong();
|
|
|
|
if (song >= 0) {
|
2008-09-07 13:57:43 +02:00
|
|
|
client_printf(client,
|
|
|
|
COMMAND_STATUS_SONG ": %i\n"
|
|
|
|
COMMAND_STATUS_SONGID ": %i\n",
|
|
|
|
song, getPlaylistSongId(song));
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
if (getPlayerState() != PLAYER_STATE_STOP) {
|
2008-09-07 13:52:48 +02:00
|
|
|
client_printf(client,
|
2008-09-07 13:57:43 +02:00
|
|
|
COMMAND_STATUS_TIME ": %i:%i\n"
|
|
|
|
COMMAND_STATUS_BITRATE ": %li\n"
|
|
|
|
COMMAND_STATUS_AUDIO ": %u:%i:%i\n",
|
2008-09-07 13:52:48 +02:00
|
|
|
getPlayerElapsedTime(), getPlayerTotalTime(),
|
2008-09-07 13:57:43 +02:00
|
|
|
getPlayerBitRate(),
|
2008-09-07 13:52:48 +02:00
|
|
|
getPlayerSampleRate(), getPlayerBits(),
|
|
|
|
getPlayerChannels());
|
2004-06-09 04:50:44 +02:00
|
|
|
}
|
2006-07-20 18:02:40 +02:00
|
|
|
|
|
|
|
if ((updateJobId = isUpdatingDB())) {
|
2008-09-07 13:57:43 +02:00
|
|
|
client_printf(client,
|
|
|
|
COMMAND_STATUS_UPDATING_DB ": %i\n",
|
|
|
|
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) {
|
2008-09-07 13:57:43 +02:00
|
|
|
client_printf(client,
|
|
|
|
COMMAND_STATUS_ERROR ": %s\n",
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleKill(mpd_unused struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused 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
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleClose(mpd_unused struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused 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
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleAdd(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-29 20:54:56 +02:00
|
|
|
char *path = argv[1];
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2005-05-03 04:35:19 +02:00
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
if (isRemoteUrl(path))
|
2008-09-07 13:39:31 +02:00
|
|
|
return addToPlaylist(path, NULL);
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2008-09-07 13:48:37 +02:00
|
|
|
result = addAllIn(path);
|
|
|
|
if (result == (enum playlist_result)-1) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST,
|
|
|
|
"directory or file not found");
|
2008-09-07 13:48:37 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleAddId(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
int argc, char *argv[])
|
2004-11-03 00:44:33 +01:00
|
|
|
{
|
2008-01-26 13:46:49 +01:00
|
|
|
int added_id;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result = addToPlaylist(argv[1], &added_id);
|
|
|
|
|
2008-09-23 23:59:55 +02:00
|
|
|
if (result != PLAYLIST_RESULT_SUCCESS)
|
2008-09-07 13:39:31 +02:00
|
|
|
return result;
|
|
|
|
|
|
|
|
if (argc == 3) {
|
|
|
|
int to;
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &to, argv[2],
|
2008-09-07 13:39:31 +02:00
|
|
|
check_integer, argv[2]) < 0)
|
|
|
|
return -1;
|
|
|
|
result = moveSongInPlaylistById(added_id, to);
|
|
|
|
if (result != PLAYLIST_RESULT_SUCCESS) {
|
2008-09-07 13:52:48 +02:00
|
|
|
int ret = print_playlist_result(client, result);
|
2008-09-07 13:39:31 +02:00
|
|
|
deleteFromPlaylistById(added_id);
|
|
|
|
return ret;
|
2008-01-26 13:46:56 +01:00
|
|
|
}
|
|
|
|
}
|
2008-09-07 13:39:31 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
client_printf(client, "Id: %d\n", added_id);
|
2008-09-07 13:39:31 +02:00
|
|
|
return result;
|
2004-11-03 00:44:33 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleDelete(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int song;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &song, argv[1], need_positive) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
|
|
|
|
result = deleteFromPlaylist(song);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleDeleteId(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-06-09 04:50:44 +02:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int id;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2004-06-09 04:50:44 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &id, argv[1], need_positive) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
|
|
|
|
result = deleteFromPlaylistById(id);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2004-06-09 04:50:44 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlaylist(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-09-07 14:02:52 +02:00
|
|
|
showPlaylist(client);
|
2008-09-07 13:39:19 +02:00
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
static int handleShuffle(mpd_unused struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-09-07 13:39:31 +02:00
|
|
|
shufflePlaylist();
|
2008-09-07 13:39:19 +02:00
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleClear(mpd_unused struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-08-26 08:27:16 +02:00
|
|
|
clearPlaylist();
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleSave(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
|
|
|
|
|
|
|
result = savePlaylist(argv[1]);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleLoad(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-09-07 13:44:12 +02:00
|
|
|
enum playlist_result result;
|
|
|
|
|
2008-09-07 13:57:26 +02:00
|
|
|
result = loadPlaylist(client, argv[1]);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
2006-07-14 20:47:55 +02:00
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleListPlaylist(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-03-26 15:46:05 +02:00
|
|
|
{
|
2008-09-07 13:44:20 +02:00
|
|
|
int ret;
|
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
ret = PlaylistInfo(client, argv[1], 0);
|
2008-09-07 13:44:20 +02:00
|
|
|
if (ret == -1)
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST, "No such playlist");
|
2008-09-07 13:44:20 +02:00
|
|
|
|
|
|
|
return ret;
|
2006-03-26 15:46:05 +02:00
|
|
|
}
|
2006-07-14 20:47:55 +02:00
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleListPlaylistInfo(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-03-26 15:46:05 +02:00
|
|
|
{
|
2008-09-07 13:44:20 +02:00
|
|
|
int ret;
|
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
ret = PlaylistInfo(client, argv[1], 1);
|
2008-09-07 13:44:20 +02:00
|
|
|
if (ret == -1)
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST, "No such playlist");
|
2008-09-07 13:44:20 +02:00
|
|
|
|
|
|
|
return ret;
|
2006-03-26 15:46:05 +02:00
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleLsInfo(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-02-05 11:17:33 +01:00
|
|
|
const char *path = "";
|
2008-10-08 11:07:39 +02:00
|
|
|
const struct directory *directory;
|
2007-05-24 19:06:59 +02:00
|
|
|
|
|
|
|
if (argc == 2)
|
|
|
|
path = argv[1];
|
|
|
|
|
2008-10-08 11:07:55 +02:00
|
|
|
directory = db_get_directory(path);
|
2008-10-08 11:07:39 +02:00
|
|
|
if (directory == NULL) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST,
|
|
|
|
"directory not found");
|
2007-05-24 19:06:59 +02:00
|
|
|
return -1;
|
2008-09-07 13:49:01 +02:00
|
|
|
}
|
2007-05-24 19:06:59 +02:00
|
|
|
|
2008-10-08 11:07:39 +02:00
|
|
|
directory_print(client, directory);
|
|
|
|
|
2007-05-24 19:06:59 +02:00
|
|
|
if (isRootDirectory(path))
|
2008-09-07 14:02:40 +02:00
|
|
|
return lsPlaylists(client, path);
|
2007-05-24 19:06:59 +02:00
|
|
|
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleRm(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
|
|
|
|
|
|
|
result = deletePlaylist(argv[1]);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleRename(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2007-05-24 20:07:19 +02:00
|
|
|
{
|
2008-09-07 13:44:12 +02:00
|
|
|
enum playlist_result result;
|
|
|
|
|
|
|
|
result = renameStoredPlaylist(argv[1], argv[2]);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2007-05-24 20:07:19 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlaylistChanges(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-06-05 03:14:37 +02:00
|
|
|
{
|
2008-09-29 15:49:29 +02:00
|
|
|
uint32_t version;
|
2004-06-05 03:14:37 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_uint32(client, &version, argv[1], need_positive) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:53:55 +02:00
|
|
|
return playlistChanges(client, version);
|
2004-06-05 03:14:37 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlaylistChangesPosId(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-04-23 13:10:41 +02:00
|
|
|
{
|
2008-09-29 15:49:29 +02:00
|
|
|
uint32_t version;
|
2006-04-23 13:10:41 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_uint32(client, &version, argv[1], need_positive) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 14:02:52 +02:00
|
|
|
return playlistChangesPosId(client, version);
|
2006-04-23 13:10:41 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlaylistInfo(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int song = -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (argc == 2 && check_int(client, &song, argv[1], need_positive) < 0)
|
2008-01-26 13:46:53 +01:00
|
|
|
return -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
result = playlistInfo(client, song);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlaylistId(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
int argc, char *argv[])
|
2004-06-09 04:50:44 +02:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
int id = -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (argc == 2 && check_int(client, &id, argv[1], need_positive) < 0)
|
2008-01-26 13:46:53 +01:00
|
|
|
return -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
result = playlistId(client, id);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2004-06-09 04:50:44 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleFind(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
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) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_ARG, "incorrect arguments");
|
2004-11-10 22:58:27 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
ret = findSongsIn(client, NULL, numItems, items);
|
2008-09-07 13:48:37 +02:00
|
|
|
if (ret == -1)
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST,
|
|
|
|
"directory or file not found");
|
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
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleSearch(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
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) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_ARG, "incorrect arguments");
|
2004-11-10 22:58:27 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
ret = searchForSongsIn(client, NULL, numItems, items);
|
2008-09-07 13:48:37 +02:00
|
|
|
if (ret == -1)
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST,
|
|
|
|
"directory or file not found");
|
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
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleCount(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
int argc, char *argv[])
|
2007-04-26 01:46:11 +02:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
LocateTagItem *items;
|
|
|
|
int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
|
|
|
|
argc - 1,
|
|
|
|
&items);
|
|
|
|
|
|
|
|
if (numItems <= 0) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_ARG, "incorrect arguments");
|
2007-04-26 01:46:11 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
ret = searchStatsForSongsIn(client, NULL, numItems, items);
|
2008-09-07 13:48:37 +02:00
|
|
|
if (ret == -1)
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST,
|
|
|
|
"directory or file not found");
|
2007-04-26 01:46:11 +02:00
|
|
|
|
|
|
|
freeLocateTagItemArray(numItems, items);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlaylistFind(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
int argc, char *argv[])
|
2007-02-24 03:00:03 +01:00
|
|
|
{
|
|
|
|
LocateTagItem *items;
|
|
|
|
int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
|
|
|
|
argc - 1,
|
|
|
|
&items);
|
|
|
|
|
|
|
|
if (numItems <= 0) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_ARG, "incorrect arguments");
|
2007-02-24 03:00:03 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
findSongsInPlaylist(client, numItems, items);
|
2007-02-24 03:00:03 +01:00
|
|
|
|
|
|
|
freeLocateTagItemArray(numItems, items);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlaylistSearch(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
int argc, char *argv[])
|
2007-02-24 03:00:03 +01:00
|
|
|
{
|
|
|
|
LocateTagItem *items;
|
|
|
|
int numItems = newLocateTagItemArrayFromArgArray(argv + 1,
|
|
|
|
argc - 1,
|
|
|
|
&items);
|
|
|
|
|
|
|
|
if (numItems <= 0) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_ARG, "incorrect arguments");
|
2007-02-24 03:00:03 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
searchForSongsInPlaylist(client, numItems, items);
|
2007-02-24 03:00:03 +01:00
|
|
|
|
|
|
|
freeLocateTagItemArray(numItems, items);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlaylistDelete(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[]) {
|
2007-05-16 14:02:10 +02:00
|
|
|
char *playlist = argv[1];
|
|
|
|
int from;
|
2008-09-07 13:44:12 +02:00
|
|
|
enum playlist_result result;
|
2007-05-16 14:02:10 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &from, argv[2], check_integer, argv[2]) < 0)
|
2007-05-16 14:02:10 +02:00
|
|
|
return -1;
|
|
|
|
|
2008-09-07 13:44:12 +02:00
|
|
|
result = removeOneSongFromStoredPlaylistByPath(playlist, from);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2007-05-16 14:02:10 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlaylistMove(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused mpd_unused int argc, char *argv[])
|
2007-05-16 14:02:10 +02:00
|
|
|
{
|
|
|
|
char *playlist = argv[1];
|
|
|
|
int from, to;
|
2008-09-07 13:44:12 +02:00
|
|
|
enum playlist_result result;
|
2007-05-16 14:02:10 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &from, argv[2], check_integer, argv[2]) < 0)
|
2007-05-16 14:02:10 +02:00
|
|
|
return -1;
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &to, argv[3], check_integer, argv[3]) < 0)
|
2007-05-16 14:02:10 +02:00
|
|
|
return -1;
|
|
|
|
|
2008-09-07 13:44:12 +02:00
|
|
|
result = moveSongInStoredPlaylistByPath(playlist, from, to);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2007-05-16 14:02:10 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleUpdate(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-10-06 18:32:27 +02:00
|
|
|
char *path = NULL;
|
2008-10-09 19:17:44 +02:00
|
|
|
int ret;
|
2008-09-07 13:50:06 +02:00
|
|
|
|
2008-10-06 18:32:27 +02:00
|
|
|
assert(argc <= 2);
|
|
|
|
if (argc == 2 && !(path = sanitizePathDup(argv[1]))) {
|
|
|
|
command_error(client, ACK_ERROR_ARG, "invalid path");
|
|
|
|
return -1;
|
2004-04-11 19:37:47 +02:00
|
|
|
}
|
2008-10-09 19:17:44 +02:00
|
|
|
|
|
|
|
ret = directory_update_init(path);
|
|
|
|
if (ret > 0) {
|
|
|
|
client_printf(client, "updating_db: %i\n", ret);
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
command_error(client, ACK_ERROR_UPDATE_ALREADY,
|
|
|
|
"already updating");
|
|
|
|
return -1;
|
|
|
|
}
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleNext(mpd_unused struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-08-26 08:27:16 +02:00
|
|
|
nextSongInPlaylist();
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePrevious(mpd_unused struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-08-26 08:27:16 +02:00
|
|
|
previousSongInPlaylist();
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleListAll(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2006-07-20 18:02:40 +02:00
|
|
|
char *directory = NULL;
|
2008-09-07 13:48:37 +02:00
|
|
|
int ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2006-07-29 20:54:56 +02:00
|
|
|
if (argc == 2)
|
|
|
|
directory = argv[1];
|
2008-09-07 13:48:37 +02:00
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
ret = printAllIn(client, directory);
|
2008-09-07 13:48:37 +02:00
|
|
|
if (ret == -1)
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST,
|
|
|
|
"directory or file not found");
|
2008-09-07 13:48:37 +02:00
|
|
|
|
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleVolume(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-09-07 13:50:16 +02:00
|
|
|
int change, ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &change, argv[1], need_integer) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:50:16 +02:00
|
|
|
|
|
|
|
ret = changeVolumeLevel(change, 1);
|
|
|
|
if (ret == -1)
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_SYSTEM,
|
|
|
|
"problems setting volume");
|
2008-09-07 13:50:16 +02:00
|
|
|
|
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleSetVol(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-09-07 13:50:16 +02:00
|
|
|
int level, ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &level, argv[1], need_integer) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:50:16 +02:00
|
|
|
|
|
|
|
ret = changeVolumeLevel(level, 0);
|
|
|
|
if (ret == -1)
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_SYSTEM,
|
|
|
|
"problems setting volume");
|
2008-09-07 13:50:16 +02:00
|
|
|
|
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleRepeat(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused 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-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &status, argv[1], need_integer) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:38:59 +02:00
|
|
|
|
|
|
|
if (status != 0 && status != 1) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_ARG,
|
|
|
|
"\"%i\" is not 0 or 1", status);
|
2008-09-07 13:38:59 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
setPlaylistRepeatStatus(status);
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleRandom(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused 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-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &status, argv[1], need_integer) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:38:59 +02:00
|
|
|
|
|
|
|
if (status != 0 && status != 1) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_ARG,
|
|
|
|
"\"%i\" is not 0 or 1", status);
|
2008-09-07 13:38:59 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
setPlaylistRandomStatus(status);
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleStats(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-09-07 14:02:57 +02:00
|
|
|
return printStats(client);
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleClearError(mpd_unused struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused 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
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleList(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
int argc, char *argv[])
|
2004-02-24 00:41:20 +01:00
|
|
|
{
|
2008-03-26 11:37:36 +01:00
|
|
|
int numConditionals;
|
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) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, 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) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_ARG,
|
|
|
|
"\"any\" is not a valid return tag type");
|
2006-12-11 21:18:04 +01:00
|
|
|
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) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_ARG,
|
|
|
|
"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) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_ARG,
|
|
|
|
"not able to parse args");
|
2004-11-12 02:44:27 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2006-07-14 20:47:55 +02:00
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
ret = listAllUniqueTags(client, 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
|
|
|
|
2008-09-07 13:48:37 +02:00
|
|
|
if (ret == -1)
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST,
|
|
|
|
"directory or file not found");
|
2008-09-07 13:48:37 +02:00
|
|
|
|
2004-11-10 22:58:27 +01:00
|
|
|
return ret;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleMove(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
int from, to;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &from, argv[1], check_integer, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &to, argv[2], check_integer, argv[2]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
result = moveSongInPlaylist(from, to);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleMoveId(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
int id, to;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &id, argv[1], check_integer, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &to, argv[2], check_integer, argv[2]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
result = moveSongInPlaylistById(id, to);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleSwap(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
int song1, song2;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &song1, argv[1], check_integer, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &song2, argv[2], check_integer, argv[2]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
result = swapSongsInPlaylist(song1, song2);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleSwapId(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
int id1, id2;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &id1, argv[1], check_integer, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &id2, argv[2], check_integer, argv[2]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
result = swapSongsInPlaylistById(id1, id2);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleSeek(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
int song, seek_time;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &song, argv[1], check_integer, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &seek_time, argv[2], check_integer, argv[2]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
|
|
|
|
result = seekSongInPlaylist(song, seek_time);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleSeekId(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-01-26 13:46:53 +01:00
|
|
|
int id, seek_time;
|
2008-09-07 13:39:31 +02:00
|
|
|
enum playlist_result result;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &id, argv[1], check_integer, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &seek_time, argv[2], check_integer, argv[2]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:39:31 +02:00
|
|
|
|
|
|
|
result = seekSongInPlaylistById(id, seek_time);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleListAllInfo(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
|
|
|
char *directory = NULL;
|
2008-09-07 13:48:37 +02:00
|
|
|
int ret;
|
2006-07-20 18:02:40 +02:00
|
|
|
|
2006-07-29 20:54:56 +02:00
|
|
|
if (argc == 2)
|
|
|
|
directory = argv[1];
|
2008-09-07 13:52:48 +02:00
|
|
|
|
2008-09-07 13:53:55 +02:00
|
|
|
ret = printInfoForAllIn(client, directory);
|
2008-09-07 13:48:37 +02:00
|
|
|
if (ret == -1)
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST,
|
|
|
|
"directory or file not found");
|
2008-09-07 13:48:37 +02:00
|
|
|
|
|
|
|
return ret;
|
2006-07-20 18:02:40 +02:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePing(mpd_unused struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePassword(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-07-20 18:02:40 +02:00
|
|
|
{
|
2008-09-07 19:17:25 +02:00
|
|
|
int permission = 0;
|
|
|
|
|
|
|
|
if (getPermissionFromPassword(argv[1], &permission) < 0) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_PASSWORD, "incorrect password");
|
2004-02-24 00:41:20 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
client_set_permission(client, permission);
|
|
|
|
|
2004-02-24 00:41:20 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleCrossfade(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused 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-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &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;
|
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleEnableDevice(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-11-02 23:13:58 +01:00
|
|
|
{
|
2008-09-07 13:51:50 +02:00
|
|
|
int device, ret;
|
2004-11-02 23:13:58 +01:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &device, argv[1], check_non_negative, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:51:50 +02:00
|
|
|
|
|
|
|
ret = enableAudioDevice(device);
|
|
|
|
if (ret == -1)
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST,
|
|
|
|
"No such audio output");
|
2008-09-07 13:51:50 +02:00
|
|
|
|
|
|
|
return ret;
|
2004-11-02 23:13:58 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleDisableDevice(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2004-11-02 23:13:58 +01:00
|
|
|
{
|
2008-09-07 13:51:50 +02:00
|
|
|
int device, ret;
|
2004-11-02 23:13:58 +01:00
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
if (check_int(client, &device, argv[1], check_non_negative, argv[1]) < 0)
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
2008-09-07 13:51:50 +02:00
|
|
|
|
|
|
|
ret = disableAudioDevice(device);
|
|
|
|
if (ret == -1)
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST,
|
|
|
|
"No such audio output");
|
2008-09-07 13:51:50 +02:00
|
|
|
|
|
|
|
return ret;
|
2004-11-02 23:13:58 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleDevices(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-11-03 00:08:00 +01:00
|
|
|
{
|
2008-09-07 14:04:16 +02:00
|
|
|
printAudioDevices(client);
|
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 */
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleCommands(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-11-08 19:01:36 +01:00
|
|
|
{
|
2008-09-07 19:17:25 +02:00
|
|
|
const int permission = client_get_permission(client);
|
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;
|
2008-09-07 19:17:25 +02:00
|
|
|
if (cmd->reqPermission == (permission & cmd->reqPermission)) {
|
2008-09-07 13:52:48 +02:00
|
|
|
client_printf(client, "command: %s\n", cmd->cmd);
|
2004-11-08 19:01:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handleNotcommands(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, mpd_unused char *argv[])
|
2004-11-23 20:46:33 +01:00
|
|
|
{
|
2008-09-07 19:17:25 +02:00
|
|
|
const int permission = client_get_permission(client);
|
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;
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
if (cmd->reqPermission != (permission & cmd->reqPermission)) {
|
2008-09-07 13:52:48 +02:00
|
|
|
client_printf(client, "command: %s\n", cmd->cmd);
|
2004-11-23 20:46:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
node = node->nextNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlaylistClear(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-12-07 15:41:40 +01:00
|
|
|
{
|
2008-09-07 13:44:12 +02:00
|
|
|
enum playlist_result result;
|
|
|
|
|
|
|
|
result = clearStoredPlaylist(argv[1]);
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2006-12-07 15:41:40 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
static int handlePlaylistAdd(struct client *client,
|
2008-08-26 08:27:02 +02:00
|
|
|
mpd_unused int argc, char *argv[])
|
2006-12-07 15:41:40 +01:00
|
|
|
{
|
|
|
|
char *playlist = argv[1];
|
|
|
|
char *path = argv[2];
|
2008-09-07 13:44:12 +02:00
|
|
|
enum playlist_result result;
|
2006-12-07 15:41:40 +01:00
|
|
|
|
|
|
|
if (isRemoteUrl(path))
|
2008-09-07 13:44:12 +02:00
|
|
|
result = addToStoredPlaylist(path, playlist);
|
|
|
|
else
|
2008-09-07 13:48:37 +02:00
|
|
|
result = addAllInToStoredPlaylist(path, playlist);
|
|
|
|
|
|
|
|
if (result == (enum playlist_result)-1) {
|
2008-09-07 13:52:48 +02:00
|
|
|
command_error(client, ACK_ERROR_NO_EXIST,
|
|
|
|
"directory or file not found");
|
2008-09-07 13:48:37 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-09-07 13:52:48 +02:00
|
|
|
return print_playlist_result(client, result);
|
2006-12-07 15:41:40 +01:00
|
|
|
}
|
|
|
|
|
2006-07-20 18:02:40 +02:00
|
|
|
void initCommands(void)
|
|
|
|
{
|
|
|
|
commandList = makeList(free, 1);
|
|
|
|
|
2008-10-06 18:34:18 +02:00
|
|
|
/* 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);
|
2006-07-20 18:02:40 +02:00
|
|
|
|
|
|
|
sortList(commandList);
|
|
|
|
}
|
|
|
|
|
|
|
|
void finishCommands(void)
|
|
|
|
{
|
|
|
|
freeList(commandList);
|
|
|
|
}
|
|
|
|
|
2008-09-07 13:52:36 +02:00
|
|
|
static int checkArgcAndPermission(CommandEntry * cmd, struct client *client,
|
2006-07-30 05:43:38 +02:00
|
|
|
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)) {
|
2008-09-07 13:52:36 +02:00
|
|
|
if (client != NULL)
|
|
|
|
command_error(client, ACK_ERROR_PERMISSION,
|
|
|
|
"you don't have permission for \"%s\"",
|
|
|
|
cmd->cmd);
|
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) {
|
2008-09-07 13:52:36 +02:00
|
|
|
if (client != NULL)
|
|
|
|
command_error(client, ACK_ERROR_ARG,
|
|
|
|
"wrong number of arguments for \"%s\"",
|
|
|
|
argv[0]);
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
|
|
|
} else if (argc < min) {
|
2008-09-07 13:52:36 +02:00
|
|
|
if (client != NULL)
|
|
|
|
command_error(client, ACK_ERROR_ARG,
|
|
|
|
"too few arguments for \"%s\"", argv[0]);
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
|
|
|
} else if (argc > max && max /* != 0 */ ) {
|
2008-09-07 13:52:36 +02:00
|
|
|
if (client != NULL)
|
|
|
|
command_error(client, ACK_ERROR_ARG,
|
|
|
|
"too many arguments for \"%s\"", argv[0]);
|
2006-07-20 18:02:40 +02:00
|
|
|
return -1;
|
|
|
|
} else
|
|
|
|
return 0;
|
2004-02-24 00:41:20 +01:00
|
|
|
}
|
|
|
|
|
2008-09-07 13:52:36 +02:00
|
|
|
static CommandEntry *getCommandEntryAndCheckArgcAndPermission(struct client *client,
|
2008-09-07 19:15:45 +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)) {
|
2008-09-07 13:52:36 +02:00
|
|
|
if (client != NULL)
|
|
|
|
command_error(client, ACK_ERROR_UNKNOWN,
|
|
|
|
"unknown command \"%s\"", argv[0]);
|
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;
|
|
|
|
|
2008-09-07 19:15:45 +02:00
|
|
|
if (checkArgcAndPermission(cmd, client, permission, argc, argv) < 0) {
|
2004-04-11 19:37:47 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cmd;
|
|
|
|
}
|
|
|
|
|
2008-10-06 18:39:33 +02:00
|
|
|
int processCommand(struct client *client, char *commandString)
|
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;
|
|
|
|
|
2008-10-06 18:39:33 +02:00
|
|
|
if (!(argc = buffer2array(commandString, argv, COMMAND_ARGV_MAX)))
|
2006-07-20 18:02:40 +02:00
|
|
|
return 0;
|
2004-04-11 19:37:47 +02:00
|
|
|
|
2008-10-06 18:39:33 +02:00
|
|
|
cmd = getCommandEntryAndCheckArgcAndPermission(client,
|
|
|
|
client_get_permission(client),
|
|
|
|
argc, argv);
|
|
|
|
if (cmd)
|
|
|
|
ret = cmd->handler(client, argc, argv);
|
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;
|
|
|
|
}
|
|
|
|
|
2008-09-07 19:17:25 +02:00
|
|
|
int processListOfCommands(struct client *client,
|
2006-07-30 05:43:38 +02:00
|
|
|
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);
|
2008-10-06 18:39:33 +02:00
|
|
|
ret = processCommand(client, cur->data);
|
2006-07-20 18:02:40 +02:00
|
|
|
DEBUG("processListOfCommands: command returned %i\n", ret);
|
2008-08-29 09:37:11 +02:00
|
|
|
if (ret != 0 || client_is_expired(client))
|
2006-07-30 05:43:38 +02:00
|
|
|
goto out;
|
2006-07-20 18:02:40 +02:00
|
|
|
else if (listOK)
|
2008-09-07 13:24:51 +02:00
|
|
|
client_puts(client, "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
|
|
|
}
|