![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/libmpdclient.c b/src/libmpdclient.c
index b61e2d1e9e33bf6dbfb33ac4e17df470f92c70e7..b0498445e0adafd997922e17f950835297da4905 100644 (file)
--- a/src/libmpdclient.c
+++ b/src/libmpdclient.c
/* libmpdclient
- * (c)2003-2004 by Warren Dukes (shank@mercury.chem.pitt.edu)
- * This project's homepage is: http://www.musicpd.org
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library 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 Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser 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
- */
+ (c)2003-2006 by Warren Dukes (warren.dukes@gmail.com)
+ This project's homepage is: http://www.musicpd.org
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ - Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ - Neither the name of the Music Player Daemon nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
#include "libmpdclient.h"
+#include "str_pool.h"
#include <errno.h>
#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
#include <stdio.h>
#include <sys/param.h>
#include <string.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#ifndef HAVE_SOCKLEN_T
-typedef SOCKLEN_T socklen_t;
-#endif
+#include <fcntl.h>
+
+#ifdef WIN32
+# include <ws2tcpip.h>
+# include <winsock.h>
+#else
+# include <netinet/in.h>
+# include <arpa/inet.h>
+# include <sys/socket.h>
+# include <netdb.h>
#endif
-#ifndef MPD_NO_IPV6
-#ifdef AF_INET6
-#define MPD_HAVE_IPV6
-#endif
+#ifndef WIN32
+#include <sys/un.h>
#endif
-#ifdef MPD_HAVE_IPV6
-int mpd_ipv6Supported() {
- int s;
- s = socket(AF_INET6,SOCK_STREAM,0);
- if(s == -1) return 0;
- close(s);
- return 1;
-}
-#endif
+#ifndef MSG_DONTWAIT
+# define MSG_DONTWAIT 0
+#endif
+#ifndef MPD_NO_GAI
+# ifdef AI_ADDRCONFIG
+# define MPD_HAVE_GAI
+# endif
+#endif
-char * mpd_sanitizeArg(const char * arg) {
- size_t i;
- int count=0;
- char * ret;
+#define COMMAND_LIST 1
+#define COMMAND_LIST_OK 2
+
+#ifdef WIN32
+# define SELECT_ERRNO_IGNORE (errno == WSAEINTR || errno == WSAEINPROGRESS)
+# define SENDRECV_ERRNO_IGNORE SELECT_ERRNO_IGNORE
+#else
+# define SELECT_ERRNO_IGNORE (errno == EINTR)
+# define SENDRECV_ERRNO_IGNORE (errno == EINTR || errno == EAGAIN)
+# define winsock_dll_error(c) 0
+# define closesocket(s) close(s)
+# define WSACleanup() do { /* nothing */ } while (0)
+#endif
- for(i=0;i<strlen(arg);i++) {
- if(arg[i]=='"' || arg[i]=='\\') count++;
+#ifdef WIN32
+static int winsock_dll_error(mpd_Connection *connection)
+{
+ WSADATA wsaData;
+ if ((WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0 ||
+ LOBYTE(wsaData.wVersion) != 2 ||
+ HIBYTE(wsaData.wVersion) != 2 ) {
+ snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
+ "Could not find usable WinSock DLL.");
+ connection->error = MPD_ERROR_SYSTEM;
+ return 1;
}
+ return 0;
+}
- ret = malloc(strlen(arg)+count+1);
+static int do_connect_fail(mpd_Connection *connection,
+ const struct sockaddr *serv_addr, int addrlen)
+{
+ int iMode = 1; /* 0 = blocking, else non-blocking */
+ ioctlsocket(connection->sock, FIONBIO, (u_long FAR*) &iMode);
+ return (connect(connection->sock,serv_addr,addrlen) == SOCKET_ERROR
+ && WSAGetLastError() != WSAEWOULDBLOCK);
+}
+#else /* !WIN32 (sane operating systems) */
+static int do_connect_fail(mpd_Connection *connection,
+ const struct sockaddr *serv_addr, int addrlen)
+{
+ int flags = fcntl(connection->sock, F_GETFL, 0);
+ fcntl(connection->sock, F_SETFL, flags | O_NONBLOCK);
+ return (connect(connection->sock,serv_addr,addrlen)<0 &&
+ errno!=EINPROGRESS);
+}
+#endif /* !WIN32 */
- count = 0;
- for(i=0;i<strlen(arg)+1;i++) {
- if(arg[i]=='"' || arg[i]=='\\') {
- ret[i+count] = '\\';
- count++;
- }
- ret[i+count] = arg[i];
+#ifdef MPD_HAVE_GAI
+static int mpd_connect(mpd_Connection * connection, const char * host, int port,
+ float timeout)
+{
+ int error;
+ char service[20];
+ struct addrinfo hints;
+ struct addrinfo *res = NULL;
+ struct addrinfo *addrinfo = NULL;
+
+ /**
+ * Setup hints
+ */
+ hints.ai_flags = AI_ADDRCONFIG;
+ hints.ai_family = PF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = IPPROTO_TCP;
+ hints.ai_addrlen = 0;
+ hints.ai_addr = NULL;
+ hints.ai_canonname = NULL;
+ hints.ai_next = NULL;
+
+ snprintf(service, sizeof(service), "%d", port);
+
+ error = getaddrinfo(host, service, &hints, &addrinfo);
+
+ if (error) {
+ snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
+ "host \"%s\" not found: %s",host, gai_strerror(error));
+ connection->error = MPD_ERROR_UNKHOST;
+ return -1;
}
- return ret;
-}
+ for (res = addrinfo; res; res = res->ai_next) {
+ /* create socket */
+ connection->sock = socket(res->ai_family, SOCK_STREAM, res->ai_protocol);
+ if (connection->sock < 0) {
+ snprintf(connection->errorStr, MPD_BUFFER_MAX_LENGTH,
+ "problems creating socket: %s",
+ strerror(errno));
+ connection->error = MPD_ERROR_SYSTEM;
+ freeaddrinfo(addrinfo);
+ return -1;
+ }
-mpd_ReturnElement * mpd_newReturnElement(const char * name, const char * value)
-{
- mpd_ReturnElement * ret = malloc(sizeof(mpd_ReturnElement));
+ mpd_setConnectionTimeout(connection,timeout);
- ret->name = strdup(name);
- ret->value = strdup(value);
+ /* connect stuff */
+ if (do_connect_fail(connection, res->ai_addr, res->ai_addrlen)) {
+ /* try the next address family */
+ closesocket(connection->sock);
+ connection->sock = -1;
+ continue;
+ }
+ }
+ freeaddrinfo(addrinfo);
- return ret;
-}
+ if (connection->sock < 0) {
+ snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
+ "problems connecting to \"%s\" on port"
+ " %i: %s",host,port, strerror(errno));
+ connection->error = MPD_ERROR_CONNPORT;
-void mpd_freeReturnElement(mpd_ReturnElement * re) {
- free(re->name);
- free(re->value);
- free(re);
-}
+ return -1;
+ }
-void mpd_setConnectionTimeout(mpd_Connection * connection, float timeout) {
- connection->timeout.tv_sec = (int)timeout;
- connection->timeout.tv_usec = (int)(timeout*1e6 -
- connection->timeout.tv_sec*1000000+0.5);
+ return 0;
}
-
-mpd_Connection * mpd_newConnection(const char * host, int port, float timeout) {
- int err;
+#else /* !MPD_HAVE_GAI */
+static int mpd_connect(mpd_Connection * connection, const char * host, int port,
+ float timeout)
+{
struct hostent * he;
struct sockaddr * dest;
- socklen_t destlen;
+ int destlen;
struct sockaddr_in sin;
- char * rt;
- char * output;
- mpd_Connection * connection = malloc(sizeof(mpd_Connection));
- struct timeval tv;
- fd_set fds;
-#ifdef MPD_HAVE_IPV6
- struct sockaddr_in6 sin6;
-#endif
- strcpy(connection->buffer,"");
- connection->buflen = 0;
- connection->bufstart = 0;
- strcpy(connection->errorStr,"");
- connection->error = 0;
- connection->doneProcessing = 0;
- connection->commandList = 0;
- connection->returnElement = NULL;
if(!(he=gethostbyname(host))) {
snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
"host \"%s\" not found",host);
connection->error = MPD_ERROR_UNKHOST;
- return connection;
+ return -1;
}
memset(&sin,0,sizeof(struct sockaddr_in));
/*dest.sin_family = he->h_addrtype;*/
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
-#ifdef MPD_HAVE_IPV6
- memset(&sin6,0,sizeof(struct sockaddr_in6));
- sin6.sin6_family = AF_INET6;
- sin6.sin6_port = htons(port);
-#endif
+
switch(he->h_addrtype) {
case AF_INET:
memcpy((char *)&sin.sin_addr.s_addr,(char *)he->h_addr,
@@ -146,90 +210,207 @@ mpd_Connection * mpd_newConnection(const char * host, int port, float timeout) {
dest = (struct sockaddr *)&sin;
destlen = sizeof(struct sockaddr_in);
break;
-#ifdef MPD_HAVE_IPV6
- case AF_INET6:
- if(!mpd_ipv6Supported()) {
- strcpy(connection->errorStr,"no IPv6 suuport but a "
- "IPv6 address found\n");
- connection->error = MPD_ERROR_SYSTEM;
- return connection;
- }
- memcpy((char *)&sin6.sin6_addr.s6_addr,(char *)he->h_addr,
- he->h_length);
- dest = (struct sockaddr *)&sin6;
- destlen = sizeof(struct sockaddr_in6);
- break;
-#endif
default:
- strcpy(connection->errorStr,"address type is not IPv4 or "
- "IPv6\n");
+ strcpy(connection->errorStr,"address type is not IPv4\n");
connection->error = MPD_ERROR_SYSTEM;
- return connection;
+ return -1;
break;
}
-
+
if((connection->sock = socket(dest->sa_family,SOCK_STREAM,0))<0) {
strcpy(connection->errorStr,"problems creating socket");
connection->error = MPD_ERROR_SYSTEM;
- return connection;
+ return -1;
}
+ mpd_setConnectionTimeout(connection,timeout);
+
/* connect stuff */
- {
-#ifdef SO_RCVTIMEO
- struct timeval rcvoldto;
- struct timeval sndoldto;
- socklen_t oldlen = sizeof(struct timeval);
+ if (do_connect_fail(connection, dest, destlen)) {
+ snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
+ "problems connecting to \"%s\" on port"
+ " %i",host,port);
+ connection->error = MPD_ERROR_CONNPORT;
+ return -1;
+ }
- mpd_setConnectionTimeout(connection,timeout);
+ return 0;
+}
+#endif /* !MPD_HAVE_GAI */
- tv.tv_sec = connection->timeout.tv_sec;
- tv.tv_usec = connection->timeout.tv_usec;
+const char *const mpdTagItemKeys[MPD_TAG_NUM_OF_ITEM_TYPES] =
+{
+ "Artist",
+ "Album",
+ "Title",
+ "Track",
+ "Name",
+ "Genre",
+ "Date",
+ "Composer",
+ "Performer",
+ "Comment",
+ "Disc",
+ "filename"
+};
+
+static char * mpd_sanitizeArg(const char * arg) {
+ size_t i;
+ char * ret;
+ register const char *c;
+ register char *rc;
+
+ /* instead of counting in that loop above, just
+ * use a bit more memory and half running time
+ */
+ ret = malloc(strlen(arg) * 2 + 1);
+
+ c = arg;
+ rc = ret;
+ for(i = strlen(arg)+1; i != 0; --i) {
+ if(*c=='"' || *c=='\\')
+ *rc++ = '\\';
+ *(rc++) = *(c++);
+ }
- if(getsockopt(connection->sock,SOL_SOCKET,SO_RCVTIMEO,&rcvoldto,
- &oldlen)<0 ||
- getsockopt(connection->sock,SOL_SOCKET,
- SO_SNDTIMEO,&sndoldto,&oldlen)<0)
- {
- strcpy(connection->errorStr,"problems getting socket "
- "timeout\n");
- connection->error = MPD_ERROR_SYSTEM;
- return connection;
- }
- if(setsockopt(connection->sock,SOL_SOCKET,SO_RCVTIMEO,&tv,
- sizeof(struct timeval))<0 ||
- setsockopt(connection->sock,SOL_SOCKET,
- SO_SNDTIMEO,&tv,
- sizeof(struct timeval))<0)
- {
- strcpy(connection->errorStr,"problems setting socket "
- "timeout\n");
- connection->error = MPD_ERROR_SYSTEM;
- return connection;
- }
-#endif
- if(connect(connection->sock,dest,destlen)<0) {
- snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
- "problems connecting to \"%s\" on port"
- " %i",host,port);
- connection->error = MPD_ERROR_CONNPORT;
- return connection;
- }
-#ifdef SO_RCVTIMEO
- if(setsockopt(connection->sock,SOL_SOCKET,SO_SNDTIMEO,&rcvoldto,
- sizeof(struct timeval))<0 ||
- setsockopt(connection->sock,SOL_SOCKET,
- SO_SNDTIMEO,&sndoldto,
- sizeof(struct timeval))<0)
- {
- strcpy(connection->errorStr,"problems setting socket "
- "timeout\n");
- connection->error = MPD_ERROR_SYSTEM;
- return connection;
+ return ret;
+}
+
+static mpd_ReturnElement * mpd_newReturnElement(const char * name, const char * value)
+{
+ mpd_ReturnElement * ret = malloc(sizeof(mpd_ReturnElement));
+
+ ret->name = str_pool_get(name);
+ ret->value = str_pool_get(value);
+
+ return ret;
+}
+
+static void mpd_freeReturnElement(mpd_ReturnElement * re) {
+ str_pool_put(re->name);
+ str_pool_put(re->value);
+ free(re);
+}
+
+void mpd_setConnectionTimeout(mpd_Connection * connection, float timeout) {
+ connection->timeout.tv_sec = (int)timeout;
+ connection->timeout.tv_usec = (int)(timeout*1e6 -
+ connection->timeout.tv_sec*1000000 +
+ 0.5);
+}
+
+static int mpd_parseWelcome(mpd_Connection * connection, const char * host, int port,
+ char * output) {
+ char * tmp;
+ char * test;
+ int i;
+
+ if(strncmp(output,MPD_WELCOME_MESSAGE,strlen(MPD_WELCOME_MESSAGE))) {
+ snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
+ "mpd not running on port %i on host \"%s\"",
+ port,host);
+ connection->error = MPD_ERROR_NOTMPD;
+ return 1;
+ }
+
+ tmp = &output[strlen(MPD_WELCOME_MESSAGE)];
+
+ for(i=0;i<3;i++) {
+ if(tmp) connection->version[i] = strtol(tmp,&test,10);
+
+ if (!tmp || (test[0] != '.' && test[0] != '\0')) {
+ snprintf(connection->errorStr,
+ MPD_BUFFER_MAX_LENGTH,
+ "error parsing version number at "
+ "\"%s\"",
+ &output[strlen(MPD_WELCOME_MESSAGE)]);
+ connection->error = MPD_ERROR_NOTMPD;
+ return 1;
}
-#endif
+ tmp = ++test;
+ }
+
+ return 0;
+}
+
+#ifndef WIN32
+static int mpd_connect_un(mpd_Connection * connection,
+ const char * host, float timeout)
+{
+ int error, flags;
+ size_t path_length;
+ struct sockaddr_un sun;
+
+ path_length = strlen(host);
+ if (path_length >= sizeof(sun.sun_path)) {
+ strcpy(connection->errorStr, "unix socket path is too long");
+ connection->error = MPD_ERROR_UNKHOST;
+ return -1;
}
+ sun.sun_family = AF_UNIX;
+ memcpy(sun.sun_path, host, path_length + 1);
+
+ connection->sock = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (connection->sock < 0) {
+ strcpy(connection->errorStr, "problems creating socket");
+ connection->error = MPD_ERROR_SYSTEM;
+ return -1;
+ }
+
+ mpd_setConnectionTimeout(connection, timeout);
+
+ flags = fcntl(connection->sock, F_GETFL, 0);
+ fcntl(connection->sock, F_SETFL, flags | O_NONBLOCK);
+
+ error = connect(connection->sock, (struct sockaddr*)&sun, sizeof(sun));
+ if (error < 0) {
+ /* try the next address family */
+ close(connection->sock);
+ connection->sock = 0;
+
+ snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
+ "problems connecting to \"%s\": %s",
+ host, strerror(errno));
+ connection->error = MPD_ERROR_CONNPORT;
+ return -1;
+ }
+
+ return 0;
+}
+#endif /* WIN32 */
+
+mpd_Connection * mpd_newConnection(const char * host, int port, float timeout) {
+ int err;
+ char * rt;
+ char * output = NULL;
+ mpd_Connection * connection = malloc(sizeof(mpd_Connection));
+ struct timeval tv;
+ fd_set fds;
+ strcpy(connection->buffer,"");
+ connection->buflen = 0;
+ connection->bufstart = 0;
+ strcpy(connection->errorStr,"");
+ connection->error = 0;
+ connection->doneProcessing = 0;
+ connection->commandList = 0;
+ connection->listOks = 0;
+ connection->doneListOk = 0;
+ connection->returnElement = NULL;
+ connection->request = NULL;
+
+ if (winsock_dll_error(connection))
+ return connection;
+
+#ifndef WIN32
+ if (host[0] == '/')
+ err = mpd_connect_un(connection, host, timeout);
+ else
+#endif
+ err = mpd_connect(connection, host, port, timeout);
+ if (err < 0)
+ return connection;
+
while(!(rt = strstr(connection->buffer,"\n"))) {
tv.tv_sec = connection->timeout.tv_sec;
tv.tv_usec = connection->timeout.tv_usec;
@@ -238,26 +419,33 @@ mpd_Connection * mpd_newConnection(const char * host, int port, float timeout) {
if((err = select(connection->sock+1,&fds,NULL,NULL,&tv)) == 1) {
int readed;
readed = recv(connection->sock,
- &(connection->buffer[connection->buflen]),
- MPD_BUFFER_MAX_LENGTH-connection->buflen,0);
+ &(connection->buffer[connection->buflen]),
+ MPD_BUFFER_MAX_LENGTH-connection->buflen,0);
if(readed<=0) {
snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
- "problems getting a response from"
- " \"%s\" on port %i",host,
- port);
+ "problems getting a response from"
+ " \"%s\" on port %i : %s",host,
+ port, strerror(errno));
connection->error = MPD_ERROR_NORESPONSE;
return connection;
}
connection->buflen+=readed;
connection->buffer[connection->buflen] = '\0';
- tv.tv_sec = connection->timeout.tv_sec;
- tv.tv_usec = connection->timeout.tv_usec;
}
- else if(err<0 && errno==EINTR) continue;
+ else if(err<0) {
+ if (SELECT_ERRNO_IGNORE)
+ continue;
+ snprintf(connection->errorStr,
+ MPD_BUFFER_MAX_LENGTH,
+ "problems connecting to \"%s\" on port"
+ " %i",host,port);
+ connection->error = MPD_ERROR_CONNPORT;
+ return connection;
+ }
else {
snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
- "timeout in attempting to get a response from"
- " \"%s\" on port %i",host,port);
+ "timeout in attempting to get a response from"
+ " \"%s\" on port %i",host,port);
connection->error = MPD_ERROR_NORESPONSE;
return connection;
}
@@ -268,55 +456,11 @@ mpd_Connection * mpd_newConnection(const char * host, int port, float timeout) {
strcpy(connection->buffer,rt+1);
connection->buflen = strlen(connection->buffer);
- if(strncmp(output,MPD_WELCOME_MESSAGE,strlen(MPD_WELCOME_MESSAGE))) {
- free(output);
- snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
- "mpd not running on port %i on host \"%s\"",
- port,host);
- connection->error = MPD_ERROR_NOTMPD;
- return connection;
- }
-
- {
- char * test;
- char * version[3];
- char * tmp = &output[strlen(MPD_WELCOME_MESSAGE)];
- char * search = ".";
- int i;
-
- for(i=0;i<3;i++) {
- char * tok;
- if(i==3) search = " ";
- version[i] = strtok_r(tmp,search,&tok);
- if(!version[i]) {
- free(output);
- snprintf(connection->errorStr,
- MPD_BUFFER_MAX_LENGTH,
- "error parsing version number at "
- "\"%s\"",
- &output[strlen(MPD_WELCOME_MESSAGE)]);
- connection->error = MPD_ERROR_NOTMPD;
- return connection;
- }
- connection->version[i] = strtol(version[i],&test,10);
- if(version[i]==test || *test!='\0') {
- free(output);
- snprintf(connection->errorStr,
- MPD_BUFFER_MAX_LENGTH,
- "error parsing version number at "
- "\"%s\"",
- &output[strlen(MPD_WELCOME_MESSAGE)]);
- connection->error = MPD_ERROR_NOTMPD;
- return connection;
- }
- tmp = NULL;
- }
- }
+ if(mpd_parseWelcome(connection,host,port,output) == 0)
+ connection->doneProcessing = 1;
free(output);
- connection->doneProcessing = 1;
-
return connection;
}
}
void mpd_closeConnection(mpd_Connection * connection) {
- close(connection->sock);
+ closesocket(connection->sock);
if(connection->returnElement) free(connection->returnElement);
+ if(connection->request) free(connection->request);
free(connection);
+ WSACleanup();
}
-void mpd_executeCommand(mpd_Connection * connection, char * command) {
+static void mpd_executeCommand(mpd_Connection *connection,
+ const char *command) {
int ret;
struct timeval tv;
fd_set fds;
- char * commandPtr = command;
+ const char *commandPtr = command;
int commandLen = strlen(command);
if(!connection->doneProcessing && !connection->commandList) {
tv.tv_sec = connection->timeout.tv_sec;
tv.tv_usec = connection->timeout.tv_usec;
- while((ret = select(connection->sock+1,NULL,&fds,NULL,&tv)==1) ||
- (ret==-1 && errno==EINTR)) {
- ret = send(connection->sock,commandPtr,commandLen,
- MSG_DONTWAIT);
+ while((ret = select(connection->sock+1,NULL,&fds,NULL,&tv)==1) ||
+ (ret==-1 && SELECT_ERRNO_IGNORE)) {
+ ret = send(connection->sock,commandPtr,commandLen,MSG_DONTWAIT);
if(ret<=0)
{
- if(ret==EAGAIN || ret==EINTR) continue;
+ if (SENDRECV_ERRNO_IGNORE) continue;
snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
- "problems giving command \"%s\"",command);
+ "problems giving command \"%s\"",command);
connection->error = MPD_ERROR_SENDING;
return;
}
if(commandLen>0) {
perror("");
snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
- "timeout sending command \"%s\"",command);
+ "timeout sending command \"%s\"",command);
connection->error = MPD_ERROR_TIMEOUT;
return;
}
if(!connection->commandList) connection->doneProcessing = 0;
+ else if(connection->commandList == COMMAND_LIST_OK) {
+ connection->listOks++;
+ }
}
-void mpd_getNextReturnElement(mpd_Connection * connection) {
+static void mpd_getNextReturnElement(mpd_Connection * connection) {
char * output = NULL;
char * rt = NULL;
char * name = NULL;
int readed;
char * bufferCheck = NULL;
int err;
+ int pos;
if(connection->returnElement) mpd_freeReturnElement(connection->returnElement);
connection->returnElement = NULL;
- if(connection->doneProcessing) {
+ if(connection->doneProcessing || (connection->listOks &&
+ connection->doneListOk))
+ {
strcpy(connection->errorStr,"already done processing current command");
connection->error = 1;
return;
}
bufferCheck = connection->buffer+connection->bufstart;
- while(connection->bufstart>=connection->buflen ||
- !(rt = strstr(bufferCheck,"\n"))) {
+ while(connection->bufstart>=connection->buflen ||
+ !(rt = strchr(bufferCheck,'\n'))) {
if(connection->buflen>=MPD_BUFFER_MAX_LENGTH) {
memmove(connection->buffer,
connection->buffer+
connection->bufstart,
connection->buflen-
connection->bufstart+1);
- bufferCheck-=connection->bufstart;
connection->buflen-=connection->bufstart;
connection->bufstart = 0;
}
strcpy(connection->errorStr,"buffer overrun");
connection->error = MPD_ERROR_BUFFEROVERRUN;
connection->doneProcessing = 1;
+ connection->doneListOk = 0;
return;
}
- bufferCheck+=connection->buflen-connection->bufstart;
+ bufferCheck = connection->buffer+connection->buflen;
tv.tv_sec = connection->timeout.tv_sec;
tv.tv_usec = connection->timeout.tv_usec;
FD_ZERO(&fds);
FD_SET(connection->sock,&fds);
if((err = select(connection->sock+1,&fds,NULL,NULL,&tv) == 1)) {
readed = recv(connection->sock,
- connection->buffer+connection->buflen,
- MPD_BUFFER_MAX_LENGTH-connection->buflen,
- MSG_DONTWAIT);
- if(readed<0 && (errno==EAGAIN || errno==EINTR)) {
+ connection->buffer+connection->buflen,
+ MPD_BUFFER_MAX_LENGTH-connection->buflen,
+ MSG_DONTWAIT);
+ if(readed<0 && SENDRECV_ERRNO_IGNORE) {
continue;
}
if(readed<=0) {
strcpy(connection->errorStr,"connection"
- " closed");
+ " closed");
connection->error = MPD_ERROR_CONNCLOSED;
connection->doneProcessing = 1;
+ connection->doneListOk = 0;
return;
}
connection->buflen+=readed;
connection->buffer[connection->buflen] = '\0';
}
- else if(err<0 && errno==EINTR) continue;
+ else if(err<0 && SELECT_ERRNO_IGNORE) continue;
else {
strcpy(connection->errorStr,"connection timeout");
connection->error = MPD_ERROR_TIMEOUT;
connection->doneProcessing = 1;
+ connection->doneListOk = 0;
return;
}
}
connection->bufstart = rt - connection->buffer + 1;
if(strcmp(output,"OK")==0) {
+ if(connection->listOks > 0) {
+ strcpy(connection->errorStr, "expected more list_OK's");
+ connection->error = 1;
+ }
+ connection->listOks = 0;
connection->doneProcessing = 1;
+ connection->doneListOk = 0;
return;
}
+
+ if(strcmp(output, "list_OK") == 0) {
+ if(!connection->listOks) {
+ strcpy(connection->errorStr,
+ "got an unexpected list_OK");
+ connection->error = 1;
+ }
+ else {
+ connection->doneListOk = 1;
+ connection->listOks--;
+ }
+ return;
+ }
+
if(strncmp(output,"ACK",strlen("ACK"))==0) {
char * test;
char * needle;
int val;
-
+
strcpy(connection->errorStr, output);
connection->error = MPD_ERROR_ACK;
connection->errorCode = MPD_ACK_ERROR_UNK;
connection->errorAt = MPD_ERROR_AT_UNK;
connection->doneProcessing = 1;
+ connection->doneListOk = 0;
needle = strchr(output, '[');
if(!needle) return;
return;
}
- name = strtok_r(output,":",&tok);
- if(name && (value = strtok_r(NULL,"",&tok)) && value[0]==' ') {
+ tok = strchr(output, ':');
+ if (!tok) return;
+ pos = tok - output;
+ value = ++tok;
+ name = output;
+ name[pos] = '\0';
+
+ if(value[0]==' ') {
connection->returnElement = mpd_newReturnElement(name,&(value[1]));
}
else {
- if(!name || !value) {
- snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
- "error parsing: %s",output);
- }
- else {
- snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
+ snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
"error parsing: %s:%s",name,value);
- }
connection->errorStr[MPD_BUFFER_MAX_LENGTH] = '\0';
connection->error = 1;
}
}
void mpd_finishCommand(mpd_Connection * connection) {
- while(!connection->doneProcessing) mpd_getNextReturnElement(connection);
+ while(!connection->doneProcessing) {
+ if(connection->doneListOk) connection->doneListOk = 0;
+ mpd_getNextReturnElement(connection);
+ }
+}
+
+static void mpd_finishListOkCommand(mpd_Connection * connection) {
+ while(!connection->doneProcessing && connection->listOks &&
+ !connection->doneListOk)
+ {
+ mpd_getNextReturnElement(connection);
+ }
+}
+
+int mpd_nextListOkCommand(mpd_Connection * connection) {
+ mpd_finishListOkCommand(connection);
+ if(!connection->doneProcessing) connection->doneListOk = 0;
+ if(connection->listOks == 0 || connection->doneProcessing) return -1;
+ return 0;
+}
+
+void mpd_sendStatusCommand(mpd_Connection * connection) {
+ mpd_executeCommand(connection,"status\n");
}
mpd_Status * mpd_getStatus(mpd_Connection * connection) {
mpd_Status * status;
- mpd_executeCommand(connection,"status\n");
-
- if(connection->error) return NULL;
+ /*mpd_executeCommand(connection,"status\n");
+
+ if(connection->error) return NULL;*/
+
+ if(connection->doneProcessing || (connection->listOks &&
+ connection->doneListOk))
+ {
+ return NULL;
+ }
+
+ if(!connection->returnElement) mpd_getNextReturnElement(connection);
status = malloc(sizeof(mpd_Status));
status->volume = -1;
status->playlistLength = -1;
status->state = -1;
status->song = 0;
+ status->songid = 0;
status->elapsedTime = 0;
status->totalTime = 0;
status->bitRate = 0;
status->error = NULL;
status->updatingDb = 0;
- mpd_getNextReturnElement(connection);
if(connection->error) {
free(status);
return NULL;
else if(strcmp(re->name,"song")==0) {
status->song = atoi(re->value);
}
+ else if(strcmp(re->name,"songid")==0) {
+ status->songid = atoi(re->value);
+ }
else if(strcmp(re->name,"time")==0) {
- char * tok;
- char * copy;
- char * temp;
- copy = strdup(re->value);
- temp = strtok_r(copy,":",&tok);
- if(temp) {
- status->elapsedTime = atoi(temp);
- temp = strtok_r(NULL,"",&tok);
- if(temp) status->totalTime = atoi(temp);
+ char * tok = strchr(re->value,':');
+ /* the second strchr below is a safety check */
+ if (tok && (strchr(tok,0) > (tok+1))) {
+ /* atoi stops at the first non-[0-9] char: */
+ status->elapsedTime = atoi(re->value);
+ status->totalTime = atoi(tok+1);
}
- free(copy);
}
else if(strcmp(re->name,"error")==0) {
status->error = strdup(re->value);
status->updatingDb = atoi(re->value);
}
else if(strcmp(re->name,"audio")==0) {
- char * tok;
- char * copy;
- char * temp;
- copy = strdup(re->value);
- temp = strtok_r(copy,":",&tok);
- if(temp) {
- status->sampleRate = atoi(temp);
- temp = strtok_r(NULL,":",&tok);
- if(temp) {
- status->bits = atoi(temp);
- temp = strtok_r(NULL,"",&tok);
- if(temp) status->channels = atoi(temp);
- }
+ char * tok = strchr(re->value,':');
+ if (tok && (strchr(tok,0) > (tok+1))) {
+ status->sampleRate = atoi(re->value);
+ status->bits = atoi(++tok);
+ tok = strchr(tok,':');
+ if (tok && (strchr(tok,0) > (tok+1)))
+ status->channels = atoi(tok+1);
}
- free(copy);
}
mpd_getNextReturnElement(connection);
free(status);
}
+void mpd_sendStatsCommand(mpd_Connection * connection) {
+ mpd_executeCommand(connection,"stats\n");
+}
+
mpd_Stats * mpd_getStats(mpd_Connection * connection) {
mpd_Stats * stats;
- mpd_executeCommand(connection,"stats\n");
-
- if(connection->error) return NULL;
+ /*mpd_executeCommand(connection,"stats\n");
+
+ if(connection->error) return NULL;*/
+
+ if(connection->doneProcessing || (connection->listOks &&
+ connection->doneListOk))
+ {
+ return NULL;
+ }
+
+ if(!connection->returnElement) mpd_getNextReturnElement(connection);
stats = malloc(sizeof(mpd_Stats));
stats->numberOfArtists = 0;
stats->playTime = 0;
stats->dbPlayTime = 0;
- mpd_getNextReturnElement(connection);
if(connection->error) {
free(stats);
return NULL;
free(stats);
}
-void mpd_initSong(mpd_Song * song) {
+static void mpd_initSong(mpd_Song * song) {
song->file = NULL;
song->artist = NULL;
song->album = NULL;
song->track = NULL;
song->title = NULL;
song->name = NULL;
+ song->date = NULL;
+ /* added by Qball */
+ song->genre = NULL;
+ song->composer = NULL;
+ song->disc = NULL;
+ song->comment = NULL;
+
song->time = MPD_SONG_NO_TIME;
- song->num = MPD_SONG_NO_NUM;
+ song->pos = MPD_SONG_NO_NUM;
+ song->id = MPD_SONG_NO_ID;
}
-void mpd_finishSong(mpd_Song * song) {
- if(song->file) free(song->file);
- if(song->artist) free(song->artist);
- if(song->album) free(song->album);
- if(song->title) free(song->title);
- if(song->track) free(song->track);
- if(song->name) free(song->name);
+static void mpd_finishSong(mpd_Song * song) {
+ if(song->file) str_pool_put(song->file);
+ if(song->artist) str_pool_put(song->artist);
+ if(song->album) str_pool_put(song->album);
+ if(song->title) str_pool_put(song->title);
+ if(song->track) str_pool_put(song->track);
+ if(song->name) str_pool_put(song->name);
+ if(song->date) str_pool_put(song->date);
+ if(song->genre) str_pool_put(song->genre);
+ if(song->composer) str_pool_put(song->composer);
+ if(song->disc) str_pool_put(song->disc);
+ if(song->comment) str_pool_put(song->comment);
}
-mpd_Song * mpd_newSong() {
+mpd_Song * mpd_newSong(void) {
mpd_Song * ret = malloc(sizeof(mpd_Song));
mpd_initSong(ret);
mpd_Song * mpd_songDup(mpd_Song * song) {
mpd_Song * ret = mpd_newSong();
- if(song->file) ret->file = strdup(song->file);
- if(song->artist) ret->artist = strdup(song->artist);
- if(song->album) ret->album = strdup(song->album);
- if(song->title) ret->title = strdup(song->title);
- if(song->track) ret->track = strdup(song->track);
- if(song->name) ret->name = strdup(song->name);
+ if(song->file) ret->file = str_pool_dup(song->file);
+ if(song->artist) ret->artist = str_pool_dup(song->artist);
+ if(song->album) ret->album = str_pool_dup(song->album);
+ if(song->title) ret->title = str_pool_dup(song->title);
+ if(song->track) ret->track = str_pool_dup(song->track);
+ if(song->name) ret->name = str_pool_dup(song->name);
+ if(song->date) ret->date = str_pool_dup(song->date);
+ if(song->genre) ret->genre= str_pool_dup(song->genre);
+ if(song->composer) ret->composer= str_pool_dup(song->composer);
+ if(song->disc) ret->disc = str_pool_dup(song->disc);
+ if(song->comment) ret->comment = str_pool_dup(song->comment);
ret->time = song->time;
- ret->num = song->num;
+ ret->pos = song->pos;
+ ret->id = song->id;
return ret;
}
-void mpd_initDirectory(mpd_Directory * directory) {
+static void mpd_initDirectory(mpd_Directory * directory) {
directory->path = NULL;
}
-void mpd_finishDirectory(mpd_Directory * directory) {
- if(directory->path) free(directory->path);
+static void mpd_finishDirectory(mpd_Directory * directory) {
+ if (directory->path)
+ str_pool_put(directory->path);
}
-mpd_Directory * mpd_newDirectory () {
+mpd_Directory * mpd_newDirectory(void) {
mpd_Directory * directory = malloc(sizeof(mpd_Directory));;
mpd_initDirectory(directory);
-
+
return directory;
}
mpd_Directory * mpd_directoryDup(mpd_Directory * directory) {
mpd_Directory * ret = mpd_newDirectory();
- if(directory->path) ret->path = strdup(directory->path);
+ if (directory->path)
+ ret->path = str_pool_dup(directory->path);
return ret;
}
-void mpd_initPlaylistFile(mpd_PlaylistFile * playlist) {
+static void mpd_initPlaylistFile(mpd_PlaylistFile * playlist) {
playlist->path = NULL;
}
-void mpd_finishPlaylistFile(mpd_PlaylistFile * playlist) {
- if(playlist->path) free(playlist->path);
+static void mpd_finishPlaylistFile(mpd_PlaylistFile * playlist) {
+ if (playlist->path)
+ str_pool_put(playlist->path);
}
-mpd_PlaylistFile * mpd_newPlaylistFile() {
+mpd_PlaylistFile * mpd_newPlaylistFile(void) {
mpd_PlaylistFile * playlist = malloc(sizeof(mpd_PlaylistFile));
mpd_initPlaylistFile(playlist);
mpd_PlaylistFile * mpd_playlistFileDup(mpd_PlaylistFile * playlist) {
mpd_PlaylistFile * ret = mpd_newPlaylistFile();
- if(playlist->path) ret->path = strdup(playlist->path);
+ if (playlist->path)
+ ret->path = str_pool_dup(playlist->path);
return ret;
}
-void mpd_initInfoEntity(mpd_InfoEntity * entity) {
+static void mpd_initInfoEntity(mpd_InfoEntity * entity) {
entity->info.directory = NULL;
-}
+}
-void mpd_finishInfoEntity(mpd_InfoEntity * entity) {
+static void mpd_finishInfoEntity(mpd_InfoEntity * entity) {
if(entity->info.directory) {
if(entity->type == MPD_INFO_ENTITY_TYPE_DIRECTORY) {
mpd_freeDirectory(entity->info.directory);
}
}
-mpd_InfoEntity * mpd_newInfoEntity() {
+mpd_InfoEntity * mpd_newInfoEntity(void) {
mpd_InfoEntity * entity = malloc(sizeof(mpd_InfoEntity));
-
+
mpd_initInfoEntity(entity);
return entity;
free(entity);
}
-void mpd_sendInfoCommand(mpd_Connection * connection, char * command) {
+static void mpd_sendInfoCommand(mpd_Connection * connection, char * command) {
mpd_executeCommand(connection,command);
}
mpd_InfoEntity * mpd_getNextInfoEntity(mpd_Connection * connection) {
mpd_InfoEntity * entity = NULL;
- if(connection->doneProcessing) return NULL;
+ if(connection->doneProcessing || (connection->listOks &&
+ connection->doneListOk)) {
+ return NULL;
+ }
if(!connection->returnElement) mpd_getNextReturnElement(connection);
- if(connection->returnElement) {
+ if(connection->returnElement) {
if(strcmp(connection->returnElement->name,"file")==0) {
entity = mpd_newInfoEntity();
entity->type = MPD_INFO_ENTITY_TYPE_SONG;
entity->info.song = mpd_newSong();
- entity->info.song->file =
- strdup(connection->returnElement->value);
+ entity->info.song->file =
+ str_pool_dup(connection->returnElement->value);
}
else if(strcmp(connection->returnElement->name,
"directory")==0) {
entity = mpd_newInfoEntity();
entity->type = MPD_INFO_ENTITY_TYPE_DIRECTORY;
entity->info.directory = mpd_newDirectory();
- entity->info.directory->path =
- strdup(connection->returnElement->value);
+ entity->info.directory->path =
+ str_pool_dup(connection->returnElement->value);
}
else if(strcmp(connection->returnElement->name,"playlist")==0) {
entity = mpd_newInfoEntity();
entity->type = MPD_INFO_ENTITY_TYPE_PLAYLISTFILE;
entity->info.playlistFile = mpd_newPlaylistFile();
- entity->info.playlistFile->path =
- strdup(connection->returnElement->value);
+ entity->info.playlistFile->path =
+ str_pool_dup(connection->returnElement->value);
+ }
+ else if(strcmp(connection->returnElement->name, "cpos") == 0){
+ entity = mpd_newInfoEntity();
+ entity->type = MPD_INFO_ENTITY_TYPE_SONG;
+ entity->info.song = mpd_newSong();
+ entity->info.song->pos = atoi(connection->returnElement->value);
}
else {
connection->error = 1;
if(strcmp(re->name,"file")==0) return entity;
else if(strcmp(re->name,"directory")==0) return entity;
else if(strcmp(re->name,"playlist")==0) return entity;
+ else if(strcmp(re->name,"cpos")==0) return entity;
- if(entity->type == MPD_INFO_ENTITY_TYPE_SONG &&
+ if(entity->type == MPD_INFO_ENTITY_TYPE_SONG &&
strlen(re->value)) {
if(!entity->info.song->artist &&
strcmp(re->name,"Artist")==0) {
- entity->info.song->artist = strdup(re->value);
+ entity->info.song->artist = str_pool_dup(re->value);
}
else if(!entity->info.song->album &&
strcmp(re->name,"Album")==0) {
- entity->info.song->album = strdup(re->value);
+ entity->info.song->album = str_pool_dup(re->value);
}
else if(!entity->info.song->title &&
strcmp(re->name,"Title")==0) {
- entity->info.song->title = strdup(re->value);
+ entity->info.song->title = str_pool_dup(re->value);
}
else if(!entity->info.song->track &&
strcmp(re->name,"Track")==0) {
- entity->info.song->track = strdup(re->value);
+ entity->info.song->track = str_pool_dup(re->value);
}
else if(!entity->info.song->name &&
strcmp(re->name,"Name")==0) {
- entity->info.song->name = strdup(re->value);
+ entity->info.song->name = str_pool_dup(re->value);
}
else if(entity->info.song->time==MPD_SONG_NO_TIME &&
strcmp(re->name,"Time")==0) {
entity->info.song->time = atoi(re->value);
}
- else if(entity->info.song->num==MPD_SONG_NO_NUM &&
- strcmp(re->name,"Num")==0) {
- entity->info.song->num = atoi(re->value);
+ else if(entity->info.song->pos==MPD_SONG_NO_NUM &&
+ strcmp(re->name,"Pos")==0) {
+ entity->info.song->pos = atoi(re->value);
+ }
+ else if(entity->info.song->id==MPD_SONG_NO_ID &&
+ strcmp(re->name,"Id")==0) {
+ entity->info.song->id = atoi(re->value);
+ }
+ else if(!entity->info.song->date &&
+ strcmp(re->name, "Date") == 0) {
+ entity->info.song->date = str_pool_dup(re->value);
+ }
+ else if(!entity->info.song->genre &&
+ strcmp(re->name, "Genre") == 0) {
+ entity->info.song->genre = str_pool_dup(re->value);
+ }
+ else if(!entity->info.song->composer &&
+ strcmp(re->name, "Composer") == 0) {
+ entity->info.song->composer = str_pool_dup(re->value);
+ }
+ else if(!entity->info.song->disc &&
+ strcmp(re->name, "Disc") == 0) {
+ entity->info.song->disc = str_pool_dup(re->value);
+ }
+ else if(!entity->info.song->comment &&
+ strcmp(re->name, "Comment") == 0) {
+ entity->info.song->comment = str_pool_dup(re->value);
}
}
else if(entity->type == MPD_INFO_ENTITY_TYPE_DIRECTORY) {
return entity;
}
-char * mpd_getNextReturnElementNamed(mpd_Connection * connection,
- const char * name)
+static char * mpd_getNextReturnElementNamed(mpd_Connection * connection,
+ const char * name)
{
- if(connection->doneProcessing) return NULL;
+ if(connection->doneProcessing || (connection->listOks &&
+ connection->doneListOk))
+ {
+ return NULL;
+ }
mpd_getNextReturnElement(connection);
while(connection->returnElement) {
return NULL;
}
+char * mpd_getNextTag(mpd_Connection * connection,int table) {
+ if(table >= 0 && table < MPD_TAG_NUM_OF_ITEM_TYPES)
+ {
+ return mpd_getNextReturnElementNamed(connection,mpdTagItemKeys[table]);
+ }
+ return NULL;
+}
+
char * mpd_getNextArtist(mpd_Connection * connection) {
return mpd_getNextReturnElementNamed(connection,"Artist");
}
return mpd_getNextReturnElementNamed(connection,"Album");
}
-void mpd_sendPlaylistInfoCommand(mpd_Connection * connection, int songNum) {
+void mpd_sendPlaylistInfoCommand(mpd_Connection * connection, int songPos) {
char * string = malloc(strlen("playlistinfo")+25);
- sprintf(string,"playlistinfo \"%i\"\n",songNum);
+ sprintf(string,"playlistinfo \"%i\"\n",songPos);
mpd_sendInfoCommand(connection,string);
free(string);
}
+void mpd_sendPlaylistIdCommand(mpd_Connection * connection, int id) {
+ char * string = malloc(strlen("playlistid")+25);
+ sprintf(string, "playlistid \"%i\"\n", id);
+ mpd_sendInfoCommand(connection, string);
+ free(string);
+}
+
void mpd_sendPlChangesCommand(mpd_Connection * connection, long long playlist) {
char * string = malloc(strlen("plchanges")+25);
sprintf(string,"plchanges \"%lld\"\n",playlist);
@@ -971,6 +1255,13 @@ void mpd_sendPlChangesCommand(mpd_Connection * connection, long long playlist) {
free(string);
}
+void mpd_sendPlChangesPosIdCommand(mpd_Connection * connection, long long playlist) {
+ char * string = malloc(strlen("plchangesposid")+25);
+ sprintf(string,"plchangesposid \"%lld\"\n",playlist);
+ mpd_sendInfoCommand(connection,string);
+ free(string);
+}
+
void mpd_sendListallCommand(mpd_Connection * connection, const char * dir) {
char * sDir = mpd_sanitizeArg(dir);
char * string = malloc(strlen("listall")+strlen(sDir)+5);
free(sDir);
}
-void mpd_sendSearchCommand(mpd_Connection * connection, int table,
- const char * str)
+void mpd_sendCurrentSongCommand(mpd_Connection * connection) {
+ mpd_executeCommand(connection,"currentsong\n");
+}
+
+void mpd_sendSearchCommand(mpd_Connection * connection, int table,
+ const char * str)
{
char st[10];
char * string;
free(sanitStr);
}
-void mpd_sendFindCommand(mpd_Connection * connection, int table,
- const char * str)
+void mpd_sendFindCommand(mpd_Connection * connection, int table,
+ const char * str)
{
char st[10];
char * string;
free(sanitStr);
}
-void mpd_sendListCommand(mpd_Connection * connection, int table,
- const char * arg1)
+void mpd_sendListCommand(mpd_Connection * connection, int table,
+ const char * arg1)
{
char st[10];
char * string;
free(sFile);
}
-void mpd_sendDeleteCommand(mpd_Connection * connection, int songNum) {
+void mpd_sendDeleteCommand(mpd_Connection * connection, int songPos) {
char * string = malloc(strlen("delete")+25);
- sprintf(string,"delete \"%i\"\n",songNum);
+ sprintf(string,"delete \"%i\"\n",songPos);
+ mpd_sendInfoCommand(connection,string);
+ free(string);
+}
+
+void mpd_sendDeleteIdCommand(mpd_Connection * connection, int id) {
+ char * string = malloc(strlen("deleteid")+25);
+ sprintf(string, "deleteid \"%i\"\n", id);
mpd_sendInfoCommand(connection,string);
free(string);
}
mpd_executeCommand(connection,"clear\n");
}
-void mpd_sendPlayCommand(mpd_Connection * connection, int songNum) {
+void mpd_sendPlayCommand(mpd_Connection * connection, int songPos) {
char * string = malloc(strlen("play")+25);
- sprintf(string,"play \"%i\"\n",songNum);
+ sprintf(string,"play \"%i\"\n",songPos);
+ mpd_sendInfoCommand(connection,string);
+ free(string);
+}
+
+void mpd_sendPlayIdCommand(mpd_Connection * connection, int id) {
+ char * string = malloc(strlen("playid")+25);
+ sprintf(string,"playid \"%i\"\n",id);
mpd_sendInfoCommand(connection,string);
free(string);
}
mpd_executeCommand(connection,"stop\n");
}
-void mpd_sendPauseCommand(mpd_Connection * connection) {
- mpd_executeCommand(connection,"pause\n");
+void mpd_sendPauseCommand(mpd_Connection * connection, int pauseMode) {
+ char * string = malloc(strlen("pause")+25);
+ sprintf(string,"pause \"%i\"\n",pauseMode);
+ mpd_executeCommand(connection,string);
+ free(string);
}
void mpd_sendNextCommand(mpd_Connection * connection) {
free(string);
}
+void mpd_sendMoveIdCommand(mpd_Connection * connection, int id, int to) {
+ char * string = malloc(strlen("moveid")+25);
+ sprintf(string, "moveid \"%i\" \"%i\"\n", id, to);
+ mpd_sendInfoCommand(connection,string);
+ free(string);
+}
+
void mpd_sendSwapCommand(mpd_Connection * connection, int song1, int song2) {
char * string = malloc(strlen("swap")+25);
sprintf(string,"swap \"%i\" \"%i\"\n",song1,song2);
@@ -1151,6 +1470,13 @@ void mpd_sendSwapCommand(mpd_Connection * connection, int song1, int song2) {
free(string);
}
+void mpd_sendSwapIdCommand(mpd_Connection * connection, int id1, int id2) {
+ char * string = malloc(strlen("swapid")+25);
+ sprintf(string, "swapid \"%i\" \"%i\"\n", id1, id2);
+ mpd_sendInfoCommand(connection,string);
+ free(string);
+}
+
void mpd_sendSeekCommand(mpd_Connection * connection, int song, int time) {
char * string = malloc(strlen("seek")+25);
sprintf(string,"seek \"%i\" \"%i\"\n",song,time);
free(string);
}
-void mpd_sendUpdateCommand(mpd_Connection * connection) {
- mpd_executeCommand(connection,"update\n");
+void mpd_sendSeekIdCommand(mpd_Connection * connection, int id, int time) {
+ char * string = malloc(strlen("seekid")+25);
+ sprintf(string,"seekid \"%i\" \"%i\"\n",id,time);
+ mpd_sendInfoCommand(connection,string);
+ free(string);
+}
+
+void mpd_sendUpdateCommand(mpd_Connection * connection, const char *path) {
+ char *sPath = mpd_sanitizeArg(path);
+ char * string = malloc(strlen("update")+strlen(sPath)+5);
+ sprintf(string,"update \"%s\"\n",sPath);
+ mpd_sendInfoCommand(connection,string);
+ free(string);
+ free(sPath);
}
int mpd_getUpdateId(mpd_Connection * connection) {
connection->error = 1;
return;
}
- connection->commandList = 1;
+ connection->commandList = COMMAND_LIST;
mpd_executeCommand(connection,"command_list_begin\n");
}
+void mpd_sendCommandListOkBegin(mpd_Connection * connection) {
+ if(connection->commandList) {
+ strcpy(connection->errorStr,"already in command list mode");
+ connection->error = 1;
+ return;
+ }
+ connection->commandList = COMMAND_LIST_OK;
+ mpd_executeCommand(connection,"command_list_ok_begin\n");
+ connection->listOks = 0;
+}
+
void mpd_sendCommandListEnd(mpd_Connection * connection) {
if(!connection->commandList) {
strcpy(connection->errorStr,"not in command list mode");
connection->commandList = 0;
mpd_executeCommand(connection,"command_list_end\n");
}
+
+void mpd_sendOutputsCommand(mpd_Connection * connection) {
+ mpd_executeCommand(connection,"outputs\n");
+}
+
+mpd_OutputEntity * mpd_getNextOutput(mpd_Connection * connection) {
+ mpd_OutputEntity * output = NULL;
+
+ if(connection->doneProcessing || (connection->listOks &&
+ connection->doneListOk))
+ {
+ return NULL;
+ }
+
+ if(connection->error) return NULL;
+
+ output = malloc(sizeof(mpd_OutputEntity));
+ output->id = -10;
+ output->name = NULL;
+ output->enabled = 0;
+
+ if(!connection->returnElement) mpd_getNextReturnElement(connection);
+
+ while(connection->returnElement) {
+ mpd_ReturnElement * re = connection->returnElement;
+ if(strcmp(re->name,"outputid")==0) {
+ if(output!=NULL && output->id>=0) return output;
+ output->id = atoi(re->value);
+ }
+ else if(strcmp(re->name,"outputname")==0) {
+ output->name = strdup(re->value);
+ }
+ else if(strcmp(re->name,"outputenabled")==0) {
+ output->enabled = atoi(re->value);
+ }
+
+ mpd_getNextReturnElement(connection);
+ if(connection->error) {
+ free(output);
+ return NULL;
+ }
+
+ }
+
+ return output;
+}
+
+void mpd_sendEnableOutputCommand(mpd_Connection * connection, int outputId) {
+ char * string = malloc(strlen("enableoutput")+25);
+ sprintf(string,"enableoutput \"%i\"\n",outputId);
+ mpd_executeCommand(connection,string);
+ free(string);
+}
+
+void mpd_sendDisableOutputCommand(mpd_Connection * connection, int outputId) {
+ char * string = malloc(strlen("disableoutput")+25);
+ sprintf(string,"disableoutput \"%i\"\n",outputId);
+ mpd_executeCommand(connection,string);
+ free(string);
+}
+
+void mpd_freeOutputElement(mpd_OutputEntity * output) {
+ free(output->name);
+ free(output);
+}
+
+/**
+ * mpd_sendNotCommandsCommand
+ * odd naming, but it gets the not allowed commands
+ */
+
+void mpd_sendNotCommandsCommand(mpd_Connection * connection) {
+ mpd_executeCommand(connection,"notcommands\n");
+}
+
+/**
+ * mpd_sendCommandsCommand
+ * odd naming, but it gets the allowed commands
+ */
+
+void mpd_sendCommandsCommand(mpd_Connection * connection) {
+ mpd_executeCommand(connection,"commands\n");
+}
+/**
+ * Get the next returned command
+ */
+char * mpd_getNextCommand(mpd_Connection * connection) {
+ return mpd_getNextReturnElementNamed(connection,"command");
+}
+
+void mpd_startSearch(mpd_Connection * connection,int exact) {
+ if(connection->request) {
+ /* search/find allready in progress */
+ /* TODO: set error here? */
+ return;
+ }
+ if(exact){
+ connection->request = strdup("find");
+ }
+ else{
+ connection->request = strdup("search");
+ }
+}
+
+
+void mpd_startFieldSearch(mpd_Connection * connection,int field) {
+ if(connection->request) {
+ /* search/find allready in progress */
+ /* TODO: set error here? */
+ return;
+ }
+ if(field < 0 || field >= MPD_TAG_NUM_OF_ITEM_TYPES) {
+ /* set error here */
+ return;
+ }
+
+ connection->request = malloc(sizeof(char)*(
+ /* length of the field name */
+ strlen(mpdTagItemKeys[field])+
+ /* "list"+space+\0 */
+ 6
+ ));
+ sprintf(connection->request, "list %s", mpdTagItemKeys[field]);
+}
+
+
+
+void mpd_addConstraintSearch(mpd_Connection *connection,
+ int field,
+ char *name)
+{
+ char *arg = NULL;
+ if(!connection->request){
+ return;
+ }
+ if(name == NULL) {
+ return;
+ }
+ if(field < 0 || field >= MPD_TAG_NUM_OF_ITEM_TYPES) {
+ return;
+ }
+ /* clean up the query */
+ arg = mpd_sanitizeArg(name);
+ /* create space for the query */
+ connection->request = realloc(connection->request, (
+ /* length of the old string */
+ strlen(connection->request)+
+ /* space between */
+ 1+
+ /* length of the field name */
+ strlen(mpdTagItemKeys[field])+
+ /* space plus starting " */
+ 2+
+ /* length of search term */
+ strlen(arg)+
+ /* closign " +\0 that is added sprintf */
+ 2
+ )*sizeof(char));
+ /* and form the query */
+ sprintf(connection->request, "%s %s \"%s\"",
+ connection->request,
+ mpdTagItemKeys[field],
+ arg);
+ free(arg);
+}
+
+
+void mpd_commitSearch(mpd_Connection *connection)
+{
+ if(connection->request)
+ {
+ int length = strlen(connection->request);
+ /* fixing up the string for mpd to like */
+ connection->request = realloc(connection->request,
+ (length+ /* old length */
+ 2 /* closing \n and \0 */
+ )*sizeof(char));
+ connection->request[length] = '\n';
+ connection->request[length+1] = '\0';
+ /* and off we go */
+ mpd_sendInfoCommand(connection, connection->request);
+ /* clean up a bit */
+ free(connection->request);
+ connection->request = NULL;
+ }
+}
+
+/**
+ * @param connection a MpdConnection
+ * @param path the path to the playlist.
+ *
+ * List the content, with full metadata, of a stored playlist.
+ *
+ */
+void mpd_sendListPlaylistInfoCommand(mpd_Connection *connection, char *path)
+{
+ char *arg = mpd_sanitizeArg(path);
+ char *query = malloc(strlen("listplaylistinfo")+strlen(arg)+5);
+ sprintf(query, "listplaylistinfo \"%s\"\n",arg);
+ mpd_sendInfoCommand(connection, query);
+ free(arg);
+ free(query);
+}
+
+/**
+ * @param connection a MpdConnection
+ * @param path the path to the playlist.
+ *
+ * List the content of a stored playlist.
+ *
+ */
+void mpd_sendListPlaylistCommand(mpd_Connection *connection, char *path)
+{
+ char *arg = mpd_sanitizeArg(path);
+ char *query = malloc(strlen("listplaylist")+strlen(arg)+5);
+ sprintf(query, "listplaylist \"%s\"\n",arg);
+ mpd_sendInfoCommand(connection, query);
+ free(arg);
+ free(query);
+}