From 1c2ef6fc6a72e53f444e40e6d576e2ccecf57487 Mon Sep 17 00:00:00 2001 From: unknown Date: Sun, 17 Aug 2008 21:23:21 +0200 Subject: drop libmpd dependency in favor of its own libmpdclient wrapper --- src/libmpdclient.c | 1955 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1955 insertions(+) create mode 100644 src/libmpdclient.c (limited to 'src/libmpdclient.c') diff --git a/src/libmpdclient.c b/src/libmpdclient.c new file mode 100644 index 00000000..490f6194 --- /dev/null +++ b/src/libmpdclient.c @@ -0,0 +1,1955 @@ +/* libmpdclient + (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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef WIN32 +# include +# include +#else +# include +# include +# include +# include +#endif + +/* (bits+1)/3 (plus the sign character) */ +#define INTLEN ((sizeof(int) * CHAR_BIT + 1) / 3 + 1) +#define LONGLONGLEN ((sizeof(long long) * CHAR_BIT + 1) / 3 + 1) + +#define COMMAND_LIST 1 +#define COMMAND_LIST_OK 2 + +#ifndef MPD_NO_GAI +# ifdef AI_ADDRCONFIG +# define MPD_HAVE_GAI +# endif +#endif + +#ifndef MSG_DONTWAIT +# define MSG_DONTWAIT 0 +#endif + +#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 + +#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 ) { + strcpy(connection->errorStr, + "Could not find usable WinSock DLL."); + connection->error = MPD_ERROR_SYSTEM; + return 1; + } + return 0; +} + +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 */ + +#ifdef MPD_HAVE_GAI +static int mpd_connect(mpd_Connection * connection, const char * host, int port, + float timeout) +{ + int error; + char service[INTLEN+1]; + 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), "%i", port); + + error = getaddrinfo(host, service, &hints, &addrinfo); + + if (error) { + snprintf(connection->errorStr, MPD_ERRORSTR_MAX_LENGTH, + "host \"%s\" not found: %s", + host, gai_strerror(error)); + connection->error = MPD_ERROR_UNKHOST; + return -1; + } + + 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_ERRORSTR_MAX_LENGTH, + "problems creating socket: %s", + strerror(errno)); + connection->error = MPD_ERROR_SYSTEM; + freeaddrinfo(addrinfo); + return -1; + } + + mpd_setConnectionTimeout(connection, timeout); + + /* 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); + + if (connection->sock < 0) { + snprintf(connection->errorStr, MPD_ERRORSTR_MAX_LENGTH, + "problems connecting to \"%s\" on port %i: %s", + host, port, strerror(errno)); + connection->error = MPD_ERROR_CONNPORT; + + return -1; + } + + return 0; +} +#else /* !MPD_HAVE_GAI */ +static int mpd_connect(mpd_Connection * connection, const char * host, int port, + float timeout) +{ + struct hostent * he; + struct sockaddr * dest; + int destlen; + struct sockaddr_in sin; + + if(!(he=gethostbyname(host))) { + snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH, + "host \"%s\" not found",host); + connection->error = MPD_ERROR_UNKHOST; + 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); + + switch(he->h_addrtype) { + case AF_INET: + memcpy((char *)&sin.sin_addr.s_addr,(char *)he->h_addr, + he->h_length); + dest = (struct sockaddr *)&sin; + destlen = sizeof(struct sockaddr_in); + break; + default: + strcpy(connection->errorStr,"address type is not IPv4"); + connection->error = MPD_ERROR_SYSTEM; + 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 -1; + } + + mpd_setConnectionTimeout(connection,timeout); + + /* connect stuff */ + if (do_connect_fail(connection, dest, destlen)) { + snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH, + "problems connecting to \"%s\" on port" + " %i",host,port); + connection->error = MPD_ERROR_CONNPORT; + return -1; + } + + return 0; +} +#endif /* !MPD_HAVE_GAI */ + +char * mpdTagItemKeys[MPD_TAG_NUM_OF_ITEM_TYPES] = +{ + "Artist", + "Album", + "Title", + "Track", + "Name", + "Genre", + "Date", + "Composer", + "Performer", + "Comment", + "Disc", + "Filename", + "Any" +}; + +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++); + } + + return ret; +} + +static mpd_ReturnElement * mpd_newReturnElement(const char * name, const char * value) +{ + mpd_ReturnElement * ret = malloc(sizeof(mpd_ReturnElement)); + + ret->name = strdup(name); + ret->value = strdup(value); + + return ret; +} + +static void mpd_freeReturnElement(mpd_ReturnElement * re) { + free(re->name); + free(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 * rt, char * output) { + char * tmp; + char * test; + int i; + + if(strncmp(output,MPD_WELCOME_MESSAGE,strlen(MPD_WELCOME_MESSAGE))) { + snprintf(connection->errorStr,MPD_ERRORSTR_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_ERRORSTR_MAX_LENGTH, + "error parsing version number at " + "\"%s\"", + &output[strlen(MPD_WELCOME_MESSAGE)]); + connection->error = MPD_ERROR_NOTMPD; + return 1; + } + tmp = ++test; + } + + return 0; +} + +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; + + if (mpd_connect(connection, host, port, timeout) < 0) + return connection; + + while(!(rt = strstr(connection->buffer,"\n"))) { + 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) { + int readed; + readed = recv(connection->sock, + &(connection->buffer[connection->buflen]), + MPD_BUFFER_MAX_LENGTH-connection->buflen,0); + if(readed<=0) { + snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH, + "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'; + } + else if(err<0) { + if (SELECT_ERRNO_IGNORE) + continue; + snprintf(connection->errorStr, + MPD_ERRORSTR_MAX_LENGTH, + "problems connecting to \"%s\" on port" + " %i",host,port); + connection->error = MPD_ERROR_CONNPORT; + return connection; + } + else { + snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH, + "timeout in attempting to get a response from" + " \"%s\" on port %i",host,port); + connection->error = MPD_ERROR_NORESPONSE; + return connection; + } + } + + *rt = '\0'; + output = strdup(connection->buffer); + strcpy(connection->buffer,rt+1); + connection->buflen = strlen(connection->buffer); + + if(mpd_parseWelcome(connection,host,port,rt,output) == 0) connection->doneProcessing = 1; + + free(output); + + return connection; +} + +void mpd_clearError(mpd_Connection * connection) { + connection->error = 0; + connection->errorStr[0] = '\0'; +} + +void mpd_closeConnection(mpd_Connection * connection) { + closesocket(connection->sock); + if(connection->returnElement) free(connection->returnElement); + if(connection->request) free(connection->request); + free(connection); + WSACleanup(); +} + +static void mpd_executeCommand(mpd_Connection * connection, char * command) { + int ret; + struct timeval tv; + fd_set fds; + char * commandPtr = command; + int commandLen = strlen(command); + + if(!connection->doneProcessing && !connection->commandList) { + strcpy(connection->errorStr,"not done processing current command"); + connection->error = 1; + return; + } + + mpd_clearError(connection); + + FD_ZERO(&fds); + FD_SET(connection->sock,&fds); + 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 && SELECT_ERRNO_IGNORE)) { + ret = send(connection->sock,commandPtr,commandLen,MSG_DONTWAIT); + if(ret<=0) + { + if (SENDRECV_ERRNO_IGNORE) continue; + snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH, + "problems giving command \"%s\"",command); + connection->error = MPD_ERROR_SENDING; + return; + } + else { + commandPtr+=ret; + commandLen-=ret; + } + + if(commandLen<=0) break; + } + + if(commandLen>0) { + perror(""); + snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH, + "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++; + } +} + +static void mpd_getNextReturnElement(mpd_Connection * connection) { + char * output = NULL; + char * rt = NULL; + char * name = NULL; + char * value = NULL; + fd_set fds; + struct timeval tv; + char * tok = NULL; + int readed; + char * bufferCheck = NULL; + int err; + int pos; + + if(connection->returnElement) mpd_freeReturnElement(connection->returnElement); + connection->returnElement = NULL; + + 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 = strchr(bufferCheck,'\n'))) { + if(connection->buflen>=MPD_BUFFER_MAX_LENGTH) { + memmove(connection->buffer, + connection->buffer+ + connection->bufstart, + connection->buflen- + connection->bufstart+1); + connection->buflen-=connection->bufstart; + connection->bufstart = 0; + } + if(connection->buflen>=MPD_BUFFER_MAX_LENGTH) { + strcpy(connection->errorStr,"buffer overrun"); + connection->error = MPD_ERROR_BUFFEROVERRUN; + connection->doneProcessing = 1; + connection->doneListOk = 0; + return; + } + 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 && SENDRECV_ERRNO_IGNORE) { + continue; + } + if(readed<=0) { + strcpy(connection->errorStr,"connection" + " 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 && SELECT_ERRNO_IGNORE) continue; + else { + strcpy(connection->errorStr,"connection timeout"); + connection->error = MPD_ERROR_TIMEOUT; + connection->doneProcessing = 1; + connection->doneListOk = 0; + return; + } + } + + *rt = '\0'; + output = connection->buffer+connection->bufstart; + 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; + val = strtol(needle+1, &test, 10); + if(*test != '@') return; + connection->errorCode = val; + val = strtol(test+1, &test, 10); + if(*test != ']') return; + connection->errorAt = val; + return; + } + + 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 { + snprintf(connection->errorStr,MPD_ERRORSTR_MAX_LENGTH, + "error parsing: %s:%s",name,value); + connection->error = 1; + } +} + +void mpd_finishCommand(mpd_Connection * 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;*/ + + if(connection->doneProcessing || (connection->listOks && + connection->doneListOk)) + { + return NULL; + } + + if(!connection->returnElement) mpd_getNextReturnElement(connection); + + status = malloc(sizeof(mpd_Status)); + status->volume = -1; + status->repeat = 0; + status->random = 0; + status->playlist = -1; + status->playlistLength = -1; + status->state = -1; + status->song = 0; + status->songid = 0; + status->elapsedTime = 0; + status->totalTime = 0; + status->bitRate = 0; + status->sampleRate = 0; + status->bits = 0; + status->channels = 0; + status->crossfade = -1; + status->error = NULL; + status->updatingDb = 0; + + if(connection->error) { + free(status); + return NULL; + } + while(connection->returnElement) { + mpd_ReturnElement * re = connection->returnElement; + if(strcmp(re->name,"volume")==0) { + status->volume = atoi(re->value); + } + else if(strcmp(re->name,"repeat")==0) { + status->repeat = atoi(re->value); + } + else if(strcmp(re->name,"random")==0) { + status->random = atoi(re->value); + } + else if(strcmp(re->name,"playlist")==0) { + status->playlist = strtol(re->value,NULL,10); + } + else if(strcmp(re->name,"playlistlength")==0) { + status->playlistLength = atoi(re->value); + } + else if(strcmp(re->name,"bitrate")==0) { + status->bitRate = atoi(re->value); + } + else if(strcmp(re->name,"state")==0) { + if(strcmp(re->value,"play")==0) { + status->state = MPD_STATUS_STATE_PLAY; + } + else if(strcmp(re->value,"stop")==0) { + status->state = MPD_STATUS_STATE_STOP; + } + else if(strcmp(re->value,"pause")==0) { + status->state = MPD_STATUS_STATE_PAUSE; + } + else { + status->state = MPD_STATUS_STATE_UNKNOWN; + } + } + 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 = 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); + } + } + else if(strcmp(re->name,"error")==0) { + status->error = strdup(re->value); + } + else if(strcmp(re->name,"xfade")==0) { + status->crossfade = atoi(re->value); + } + else if(strcmp(re->name,"updating_db")==0) { + status->updatingDb = atoi(re->value); + } + else if(strcmp(re->name,"audio")==0) { + 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); + } + } + + mpd_getNextReturnElement(connection); + if(connection->error) { + free(status); + return NULL; + } + } + + if(connection->error) { + free(status); + return NULL; + } + else if(status->state<0) { + strcpy(connection->errorStr,"state not found"); + connection->error = 1; + free(status); + return NULL; + } + + return status; +} + +void mpd_freeStatus(mpd_Status * status) { + if(status->error) free(status->error); + 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;*/ + + if(connection->doneProcessing || (connection->listOks && + connection->doneListOk)) + { + return NULL; + } + + if(!connection->returnElement) mpd_getNextReturnElement(connection); + + stats = malloc(sizeof(mpd_Stats)); + stats->numberOfArtists = 0; + stats->numberOfAlbums = 0; + stats->numberOfSongs = 0; + stats->uptime = 0; + stats->dbUpdateTime = 0; + stats->playTime = 0; + stats->dbPlayTime = 0; + + if(connection->error) { + free(stats); + return NULL; + } + while(connection->returnElement) { + mpd_ReturnElement * re = connection->returnElement; + if(strcmp(re->name,"artists")==0) { + stats->numberOfArtists = atoi(re->value); + } + else if(strcmp(re->name,"albums")==0) { + stats->numberOfAlbums = atoi(re->value); + } + else if(strcmp(re->name,"songs")==0) { + stats->numberOfSongs = atoi(re->value); + } + else if(strcmp(re->name,"uptime")==0) { + stats->uptime = strtol(re->value,NULL,10); + } + else if(strcmp(re->name,"db_update")==0) { + stats->dbUpdateTime = strtol(re->value,NULL,10); + } + else if(strcmp(re->name,"playtime")==0) { + stats->playTime = strtol(re->value,NULL,10); + } + else if(strcmp(re->name,"db_playtime")==0) { + stats->dbPlayTime = strtol(re->value,NULL,10); + } + + mpd_getNextReturnElement(connection); + if(connection->error) { + free(stats); + return NULL; + } + } + + if(connection->error) { + free(stats); + return NULL; + } + + return stats; +} + +void mpd_freeStats(mpd_Stats * stats) { + free(stats); +} + +mpd_SearchStats * mpd_getSearchStats(mpd_Connection * connection) +{ + mpd_SearchStats * stats; + mpd_ReturnElement * re; + + if (connection->doneProcessing || + (connection->listOks && connection->doneListOk)) { + return NULL; + } + + if (!connection->returnElement) mpd_getNextReturnElement(connection); + + if (connection->error) + return NULL; + + stats = malloc(sizeof(mpd_SearchStats)); + stats->numberOfSongs = 0; + stats->playTime = 0; + + while (connection->returnElement) { + re = connection->returnElement; + + if (strcmp(re->name, "songs") == 0) { + stats->numberOfSongs = atoi(re->value); + } else if (strcmp(re->name, "playtime") == 0) { + stats->playTime = strtol(re->value, NULL, 10); + } + + mpd_getNextReturnElement(connection); + if (connection->error) { + free(stats); + return NULL; + } + } + + if (connection->error) { + free(stats); + return NULL; + } + + return stats; +} + +void mpd_freeSearchStats(mpd_SearchStats * stats) +{ + free(stats); +} + +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->performer = NULL; + song->disc = NULL; + song->comment = NULL; + + song->time = MPD_SONG_NO_TIME; + song->pos = MPD_SONG_NO_NUM; + song->id = MPD_SONG_NO_ID; +} + +static 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); + if(song->date) free(song->date); + if(song->genre) free(song->genre); + if(song->composer) free(song->composer); + if(song->disc) free(song->disc); + if(song->comment) free(song->comment); +} + +mpd_Song * mpd_newSong(void) { + mpd_Song * ret = malloc(sizeof(mpd_Song)); + + mpd_initSong(ret); + + return ret; +} + +void mpd_freeSong(mpd_Song * song) { + mpd_finishSong(song); + free(song); +} + +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->date) ret->date = strdup(song->date); + if(song->genre) ret->genre= strdup(song->genre); + if(song->composer) ret->composer= strdup(song->composer); + if(song->disc) ret->disc = strdup(song->disc); + if(song->comment) ret->comment = strdup(song->comment); + ret->time = song->time; + ret->pos = song->pos; + ret->id = song->id; + + return ret; +} + +static void mpd_initDirectory(mpd_Directory * directory) { + directory->path = NULL; +} + +static void mpd_finishDirectory(mpd_Directory * directory) { + if(directory->path) free(directory->path); +} + +mpd_Directory * mpd_newDirectory(void) { + mpd_Directory * directory = malloc(sizeof(mpd_Directory));; + + mpd_initDirectory(directory); + + return directory; +} + +void mpd_freeDirectory(mpd_Directory * directory) { + mpd_finishDirectory(directory); + + free(directory); +} + +mpd_Directory * mpd_directoryDup(mpd_Directory * directory) { + mpd_Directory * ret = mpd_newDirectory(); + + if(directory->path) ret->path = strdup(directory->path); + + return ret; +} + +static void mpd_initPlaylistFile(mpd_PlaylistFile * playlist) { + playlist->path = NULL; +} + +static void mpd_finishPlaylistFile(mpd_PlaylistFile * playlist) { + if(playlist->path) free(playlist->path); +} + +mpd_PlaylistFile * mpd_newPlaylistFile(void) { + mpd_PlaylistFile * playlist = malloc(sizeof(mpd_PlaylistFile)); + + mpd_initPlaylistFile(playlist); + + return playlist; +} + +void mpd_freePlaylistFile(mpd_PlaylistFile * playlist) { + mpd_finishPlaylistFile(playlist); + free(playlist); +} + +mpd_PlaylistFile * mpd_playlistFileDup(mpd_PlaylistFile * playlist) { + mpd_PlaylistFile * ret = mpd_newPlaylistFile(); + + if(playlist->path) ret->path = strdup(playlist->path); + + return ret; +} + +static void mpd_initInfoEntity(mpd_InfoEntity * entity) { + entity->info.directory = NULL; +} + +static void mpd_finishInfoEntity(mpd_InfoEntity * entity) { + if(entity->info.directory) { + if(entity->type == MPD_INFO_ENTITY_TYPE_DIRECTORY) { + mpd_freeDirectory(entity->info.directory); + } + else if(entity->type == MPD_INFO_ENTITY_TYPE_SONG) { + mpd_freeSong(entity->info.song); + } + else if(entity->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE) { + mpd_freePlaylistFile(entity->info.playlistFile); + } + } +} + +mpd_InfoEntity * mpd_newInfoEntity(void) { + mpd_InfoEntity * entity = malloc(sizeof(mpd_InfoEntity)); + + mpd_initInfoEntity(entity); + + return entity; +} + +void mpd_freeInfoEntity(mpd_InfoEntity * entity) { + mpd_finishInfoEntity(entity); + free(entity); +} + +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 || (connection->listOks && + connection->doneListOk)) + { + return NULL; + } + + if(!connection->returnElement) mpd_getNextReturnElement(connection); + + 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); + } + 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); + } + 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); + } + 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; + strcpy(connection->errorStr,"problem parsing song info"); + return NULL; + } + } + else return NULL; + + mpd_getNextReturnElement(connection); + while(connection->returnElement) { + mpd_ReturnElement * re = connection->returnElement; + + 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 && + strlen(re->value)) { + if(!entity->info.song->artist && + strcmp(re->name,"Artist")==0) { + entity->info.song->artist = strdup(re->value); + } + else if(!entity->info.song->album && + strcmp(re->name,"Album")==0) { + entity->info.song->album = strdup(re->value); + } + else if(!entity->info.song->title && + strcmp(re->name,"Title")==0) { + entity->info.song->title = strdup(re->value); + } + else if(!entity->info.song->track && + strcmp(re->name,"Track")==0) { + entity->info.song->track = strdup(re->value); + } + else if(!entity->info.song->name && + strcmp(re->name,"Name")==0) { + entity->info.song->name = strdup(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->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 = strdup(re->value); + } + else if(!entity->info.song->genre && + strcmp(re->name, "Genre") == 0) { + entity->info.song->genre = strdup(re->value); + } + else if(!entity->info.song->composer && + strcmp(re->name, "Composer") == 0) { + entity->info.song->composer = strdup(re->value); + } + else if(!entity->info.song->performer && + strcmp(re->name, "Performer") == 0) { + entity->info.song->performer = strdup(re->value); + } + else if(!entity->info.song->disc && + strcmp(re->name, "Disc") == 0) { + entity->info.song->disc = strdup(re->value); + } + else if(!entity->info.song->comment && + strcmp(re->name, "Comment") == 0) { + entity->info.song->comment = strdup(re->value); + } + } + else if(entity->type == MPD_INFO_ENTITY_TYPE_DIRECTORY) { + } + else if(entity->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE) { + } + + mpd_getNextReturnElement(connection); + } + + return entity; +} + +static char * mpd_getNextReturnElementNamed(mpd_Connection * connection, + const char * name) +{ + if(connection->doneProcessing || (connection->listOks && + connection->doneListOk)) + { + return NULL; + } + + mpd_getNextReturnElement(connection); + while(connection->returnElement) { + mpd_ReturnElement * re = connection->returnElement; + + if(strcmp(re->name,name)==0) return strdup(re->value); + mpd_getNextReturnElement(connection); + } + + return NULL; +} + +char *mpd_getNextTag(mpd_Connection *connection, int type) +{ + if (type < 0 || type >= MPD_TAG_NUM_OF_ITEM_TYPES || + type == MPD_TAG_ITEM_ANY) + return NULL; + if (type == MPD_TAG_ITEM_FILENAME) + return mpd_getNextReturnElementNamed(connection, "file"); + return mpd_getNextReturnElementNamed(connection, mpdTagItemKeys[type]); +} + +char * mpd_getNextArtist(mpd_Connection * connection) { + return mpd_getNextReturnElementNamed(connection,"Artist"); +} + +char * mpd_getNextAlbum(mpd_Connection * connection) { + return mpd_getNextReturnElementNamed(connection,"Album"); +} + +void mpd_sendPlaylistInfoCommand(mpd_Connection * connection, int songPos) { + int len = strlen("playlistinfo")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "playlistinfo \"%i\"\n", songPos); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendPlaylistIdCommand(mpd_Connection * connection, int id) { + int len = strlen("playlistid")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "playlistid \"%i\"\n", id); + mpd_sendInfoCommand(connection, string); + free(string); +} + +void mpd_sendPlChangesCommand(mpd_Connection * connection, long long playlist) { + int len = strlen("plchanges")+2+LONGLONGLEN+3; + char *string = malloc(len); + snprintf(string, len, "plchanges \"%lld\"\n", playlist); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendPlChangesPosIdCommand(mpd_Connection * connection, long long playlist) { + int len = strlen("plchangesposid")+2+LONGLONGLEN+3; + char *string = malloc(len); + snprintf(string, len, "plchangesposid \"%lld\"\n", playlist); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendListallCommand(mpd_Connection * connection, const char * dir) { + char * sDir = mpd_sanitizeArg(dir); + int len = strlen("listall")+2+strlen(sDir)+3; + char *string = malloc(len); + snprintf(string, len, "listall \"%s\"\n", sDir); + mpd_sendInfoCommand(connection,string); + free(string); + free(sDir); +} + +void mpd_sendListallInfoCommand(mpd_Connection * connection, const char * dir) { + char * sDir = mpd_sanitizeArg(dir); + int len = strlen("listallinfo")+2+strlen(sDir)+3; + char *string = malloc(len); + snprintf(string, len, "listallinfo \"%s\"\n", sDir); + mpd_sendInfoCommand(connection,string); + free(string); + free(sDir); +} + +void mpd_sendLsInfoCommand(mpd_Connection * connection, const char * dir) { + char * sDir = mpd_sanitizeArg(dir); + int len = strlen("lsinfo")+2+strlen(sDir)+3; + char *string = malloc(len); + snprintf(string, len, "lsinfo \"%s\"\n", sDir); + mpd_sendInfoCommand(connection,string); + free(string); + free(sDir); +} + +void mpd_sendCurrentSongCommand(mpd_Connection * connection) { + mpd_executeCommand(connection,"currentsong\n"); +} + +void mpd_sendSearchCommand(mpd_Connection * connection, int table, + const char * str) +{ + mpd_startSearch(connection, 0); + mpd_addConstraintSearch(connection, table, str); + mpd_commitSearch(connection); +} + +void mpd_sendFindCommand(mpd_Connection * connection, int table, + const char * str) +{ + mpd_startSearch(connection, 1); + mpd_addConstraintSearch(connection, table, str); + mpd_commitSearch(connection); +} + +void mpd_sendListCommand(mpd_Connection * connection, int table, + const char * arg1) +{ + char st[10]; + int len; + char *string; + if(table == MPD_TABLE_ARTIST) strcpy(st,"artist"); + else if(table == MPD_TABLE_ALBUM) strcpy(st,"album"); + else { + connection->error = 1; + strcpy(connection->errorStr,"unknown table for list"); + return; + } + if(arg1) { + char * sanitArg1 = mpd_sanitizeArg(arg1); + len = strlen("list")+1+strlen(sanitArg1)+2+strlen(st)+3; + string = malloc(len); + snprintf(string, len, "list %s \"%s\"\n", st, sanitArg1); + free(sanitArg1); + } + else { + len = strlen("list")+1+strlen(st)+2; + string = malloc(len); + snprintf(string, len, "list %s\n", st); + } + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendAddCommand(mpd_Connection * connection, const char * file) { + char * sFile = mpd_sanitizeArg(file); + int len = strlen("add")+2+strlen(sFile)+3; + char *string = malloc(len); + snprintf(string, len, "add \"%s\"\n", sFile); + mpd_executeCommand(connection,string); + free(string); + free(sFile); +} + +int mpd_sendAddIdCommand(mpd_Connection *connection, const char *file) +{ + int retval = -1; + char *sFile = mpd_sanitizeArg(file); + int len = strlen("addid")+2+strlen(sFile)+3; + char *string = malloc(len); + + snprintf(string, len, "addid \"%s\"\n", sFile); + mpd_sendInfoCommand(connection, string); + free(string); + free(sFile); + + string = mpd_getNextReturnElementNamed(connection, "Id"); + if (string) { + retval = atoi(string); + free(string); + } + + return retval; +} + +void mpd_sendDeleteCommand(mpd_Connection * connection, int songPos) { + int len = strlen("delete")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "delete \"%i\"\n", songPos); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendDeleteIdCommand(mpd_Connection * connection, int id) { + int len = strlen("deleteid")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "deleteid \"%i\"\n", id); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendSaveCommand(mpd_Connection * connection, const char * name) { + char * sName = mpd_sanitizeArg(name); + int len = strlen("save")+2+strlen(sName)+3; + char *string = malloc(len); + snprintf(string, len, "save \"%s\"\n", sName); + mpd_executeCommand(connection,string); + free(string); + free(sName); +} + +void mpd_sendLoadCommand(mpd_Connection * connection, const char * name) { + char * sName = mpd_sanitizeArg(name); + int len = strlen("load")+2+strlen(sName)+3; + char *string = malloc(len); + snprintf(string, len, "load \"%s\"\n", sName); + mpd_executeCommand(connection,string); + free(string); + free(sName); +} + +void mpd_sendRmCommand(mpd_Connection * connection, const char * name) { + char * sName = mpd_sanitizeArg(name); + int len = strlen("rm")+2+strlen(sName)+3; + char *string = malloc(len); + snprintf(string, len, "rm \"%s\"\n", sName); + mpd_executeCommand(connection,string); + free(string); + free(sName); +} + +void mpd_sendRenameCommand(mpd_Connection *connection, const char *from, + const char *to) +{ + char *sFrom = mpd_sanitizeArg(from); + char *sTo = mpd_sanitizeArg(to); + int len = strlen("rename")+2+strlen(sFrom)+3+strlen(sTo)+3; + char *string = malloc(len); + snprintf(string, len, "rename \"%s\" \"%s\"\n", sFrom, sTo); + mpd_executeCommand(connection, string); + free(string); + free(sFrom); + free(sTo); +} + +void mpd_sendShuffleCommand(mpd_Connection * connection) { + mpd_executeCommand(connection,"shuffle\n"); +} + +void mpd_sendClearCommand(mpd_Connection * connection) { + mpd_executeCommand(connection,"clear\n"); +} + +void mpd_sendPlayCommand(mpd_Connection * connection, int songPos) { + int len = strlen("play")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "play \"%i\"\n", songPos); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendPlayIdCommand(mpd_Connection * connection, int id) { + int len = strlen("playid")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "playid \"%i\"\n", id); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendStopCommand(mpd_Connection * connection) { + mpd_executeCommand(connection,"stop\n"); +} + +void mpd_sendPauseCommand(mpd_Connection * connection, int pauseMode) { + int len = strlen("pause")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "pause \"%i\"\n", pauseMode); + mpd_executeCommand(connection,string); + free(string); +} + +void mpd_sendNextCommand(mpd_Connection * connection) { + mpd_executeCommand(connection,"next\n"); +} + +void mpd_sendMoveCommand(mpd_Connection * connection, int from, int to) { + int len = strlen("move")+2+INTLEN+3+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "move \"%i\" \"%i\"\n", from, to); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendMoveIdCommand(mpd_Connection * connection, int id, int to) { + int len = strlen("moveid")+2+INTLEN+3+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "moveid \"%i\" \"%i\"\n", id, to); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendSwapCommand(mpd_Connection * connection, int song1, int song2) { + int len = strlen("swap")+2+INTLEN+3+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "swap \"%i\" \"%i\"\n", song1, song2); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendSwapIdCommand(mpd_Connection * connection, int id1, int id2) { + int len = strlen("swapid")+2+INTLEN+3+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "swapid \"%i\" \"%i\"\n", id1, id2); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendSeekCommand(mpd_Connection * connection, int song, int time) { + int len = strlen("seek")+2+INTLEN+3+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "seek \"%i\" \"%i\"\n", song, time); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendSeekIdCommand(mpd_Connection * connection, int id, int time) { + int len = strlen("seekid")+2+INTLEN+3+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "seekid \"%i\" \"%i\"\n", id, time); + mpd_sendInfoCommand(connection,string); + free(string); +} + +void mpd_sendUpdateCommand(mpd_Connection * connection, char * path) { + char * sPath = mpd_sanitizeArg(path); + int len = strlen("update")+2+strlen(sPath)+3; + char *string = malloc(len); + snprintf(string, len, "update \"%s\"\n", sPath); + mpd_sendInfoCommand(connection,string); + free(string); + free(sPath); +} + +int mpd_getUpdateId(mpd_Connection * connection) { + char * jobid; + int ret = 0; + + jobid = mpd_getNextReturnElementNamed(connection,"updating_db"); + if(jobid) { + ret = atoi(jobid); + free(jobid); + } + + return ret; +} + +void mpd_sendPrevCommand(mpd_Connection * connection) { + mpd_executeCommand(connection,"previous\n"); +} + +void mpd_sendRepeatCommand(mpd_Connection * connection, int repeatMode) { + int len = strlen("repeat")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "repeat \"%i\"\n", repeatMode); + mpd_executeCommand(connection,string); + free(string); +} + +void mpd_sendRandomCommand(mpd_Connection * connection, int randomMode) { + int len = strlen("random")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "random \"%i\"\n", randomMode); + mpd_executeCommand(connection,string); + free(string); +} + +void mpd_sendSetvolCommand(mpd_Connection * connection, int volumeChange) { + int len = strlen("setvol")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "setvol \"%i\"\n", volumeChange); + mpd_executeCommand(connection,string); + free(string); +} + +void mpd_sendVolumeCommand(mpd_Connection * connection, int volumeChange) { + int len = strlen("volume")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "volume \"%i\"\n", volumeChange); + mpd_executeCommand(connection,string); + free(string); +} + +void mpd_sendCrossfadeCommand(mpd_Connection * connection, int seconds) { + int len = strlen("crossfade")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "crossfade \"%i\"\n", seconds); + mpd_executeCommand(connection,string); + free(string); +} + +void mpd_sendPasswordCommand(mpd_Connection * connection, const char * pass) { + char * sPass = mpd_sanitizeArg(pass); + int len = strlen("password")+2+strlen(sPass)+3; + char *string = malloc(len); + snprintf(string, len, "password \"%s\"\n", sPass); + mpd_executeCommand(connection,string); + free(string); + free(sPass); +} + +void mpd_sendCommandListBegin(mpd_Connection * connection) { + if(connection->commandList) { + strcpy(connection->errorStr,"already in command list mode"); + connection->error = 1; + return; + } + 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->error = 1; + return; + } + 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) { + int len = strlen("enableoutput")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "enableoutput \"%i\"\n", outputId); + mpd_executeCommand(connection,string); + free(string); +} + +void mpd_sendDisableOutputCommand(mpd_Connection * connection, int outputId) { + int len = strlen("disableoutput")+2+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "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_sendUrlHandlersCommand(mpd_Connection * connection) +{ + mpd_executeCommand(connection, "urlhandlers\n"); +} + +char * mpd_getNextHandler(mpd_Connection * connection) +{ + return mpd_getNextReturnElementNamed(connection, "handler"); +} + +void mpd_sendTagTypesCommand(mpd_Connection * connection) +{ + mpd_executeCommand(connection, "tagtypes\n"); +} + +char * mpd_getNextTagType(mpd_Connection * connection) +{ + return mpd_getNextReturnElementNamed(connection, "tagtype"); +} + +void mpd_startSearch(mpd_Connection *connection, int exact) +{ + if (connection->request) { + strcpy(connection->errorStr, "search already in progress"); + connection->error = 1; + return; + } + + if (exact) connection->request = strdup("find"); + else connection->request = strdup("search"); +} + +void mpd_startStatsSearch(mpd_Connection *connection) +{ + if (connection->request) { + strcpy(connection->errorStr, "search already in progress"); + connection->error = 1; + return; + } + + connection->request = strdup("count"); +} + +void mpd_startPlaylistSearch(mpd_Connection *connection, int exact) +{ + if (connection->request) { + strcpy(connection->errorStr, "search already in progress"); + connection->error = 1; + return; + } + + if (exact) connection->request = strdup("playlistfind"); + else connection->request = strdup("playlistsearch"); +} + +void mpd_startFieldSearch(mpd_Connection *connection, int type) +{ + char *strtype; + int len; + + if (connection->request) { + strcpy(connection->errorStr, "search already in progress"); + connection->error = 1; + return; + } + + if (type < 0 || type >= MPD_TAG_NUM_OF_ITEM_TYPES) { + strcpy(connection->errorStr, "invalid type specified"); + connection->error = 1; + return; + } + + strtype = mpdTagItemKeys[type]; + + len = 5+strlen(strtype)+1; + connection->request = malloc(len); + + snprintf(connection->request, len, "list %c%s", + tolower(strtype[0]), strtype+1); +} + +void mpd_addConstraintSearch(mpd_Connection *connection, int type, const char *name) +{ + char *strtype; + char *arg; + int len; + char *string; + + if (!connection->request) { + strcpy(connection->errorStr, "no search in progress"); + connection->error = 1; + return; + } + + if (type < 0 || type >= MPD_TAG_NUM_OF_ITEM_TYPES) { + strcpy(connection->errorStr, "invalid type specified"); + connection->error = 1; + return; + } + + if (name == NULL) { + strcpy(connection->errorStr, "no name specified"); + connection->error = 1; + return; + } + + string = strdup(connection->request); + strtype = mpdTagItemKeys[type]; + arg = mpd_sanitizeArg(name); + + len = strlen(string)+1+strlen(strtype)+2+strlen(arg)+2; + connection->request = realloc(connection->request, len); + snprintf(connection->request, len, "%s %c%s \"%s\"", + string, tolower(strtype[0]), strtype+1, arg); + + free(string); + free(arg); +} + +void mpd_commitSearch(mpd_Connection *connection) +{ + int len; + + if (!connection->request) { + strcpy(connection->errorStr, "no search in progress"); + connection->error = 1; + return; + } + + len = strlen(connection->request)+2; + connection->request = realloc(connection->request, len); + connection->request[len-2] = '\n'; + connection->request[len-1] = '\0'; + mpd_sendInfoCommand(connection, connection->request); + + 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); + int len = strlen("listplaylistinfo")+2+strlen(arg)+3; + char *query = malloc(len); + snprintf(query, len, "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); + int len = strlen("listplaylist")+2+strlen(arg)+3; + char *query = malloc(len); + snprintf(query, len, "listplaylist \"%s\"\n", arg); + mpd_sendInfoCommand(connection, query); + free(arg); + free(query); +} + +void mpd_sendPlaylistClearCommand(mpd_Connection *connection, char *path) +{ + char *sPath = mpd_sanitizeArg(path); + int len = strlen("playlistclear")+2+strlen(sPath)+3; + char *string = malloc(len); + snprintf(string, len, "playlistclear \"%s\"\n", sPath); + mpd_executeCommand(connection, string); + free(sPath); + free(string); +} + +void mpd_sendPlaylistAddCommand(mpd_Connection *connection, + char *playlist, char *path) +{ + char *sPlaylist = mpd_sanitizeArg(playlist); + char *sPath = mpd_sanitizeArg(path); + int len = strlen("playlistadd")+2+strlen(sPlaylist)+3+strlen(sPath)+3; + char *string = malloc(len); + snprintf(string, len, "playlistadd \"%s\" \"%s\"\n", sPlaylist, sPath); + mpd_executeCommand(connection, string); + free(sPlaylist); + free(sPath); + free(string); +} + +void mpd_sendPlaylistMoveCommand(mpd_Connection *connection, + char *playlist, int from, int to) +{ + char *sPlaylist = mpd_sanitizeArg(playlist); + int len = strlen("playlistmove")+ + 2+strlen(sPlaylist)+3+INTLEN+3+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "playlistmove \"%s\" \"%i\" \"%i\"\n", + sPlaylist, from, to); + mpd_executeCommand(connection, string); + free(sPlaylist); + free(string); +} + +void mpd_sendPlaylistDeleteCommand(mpd_Connection *connection, + char *playlist, int pos) +{ + char *sPlaylist = mpd_sanitizeArg(playlist); + int len = strlen("playlistdelete")+2+strlen(sPlaylist)+3+INTLEN+3; + char *string = malloc(len); + snprintf(string, len, "playlistdelete \"%s\" \"%i\"\n", sPlaylist, pos); + mpd_executeCommand(connection, string); + free(sPlaylist); + free(string); +} -- cgit v1.2.3