src/libmpdclient.c

   1 /* libmpdclient
   2  * (c)2003-2004 by Warren Dukes (shank@mercury.chem.pitt.edu)
   3  * This project's homepage is: http://www.musicpd.org
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include "libmpdclient.h"
  21
  22 #include <errno.h>
  23 #include <sys/types.h>
  24 #include <sys/socket.h>
  25 #include <netdb.h>
  26 #include <stdio.h>
  27 #include <sys/param.h>
  28 #include <string.h>
  29 #include <netinet/in.h>
  30 #include <arpa/inet.h>
  31 #include <unistd.h>
  32 #include <stdlib.h>
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include "config.h"
  36 #ifndef HAVE_SOCKLEN_T
  37 typedef SOCKLEN_T socklen_t;
  38 #endif
  39 #endif
  40
  41 #ifndef MPD_NO_IPV6
  42 #ifdef AF_INET6
  43 #define MPD_HAVE_IPV6
  44 #endif
  45 #endif
  46
  47 #ifdef MPD_HAVE_IPV6
  48 int mpd_ipv6Supported() {
  49         int s;
  50         s = socket(AF_INET6,SOCK_STREAM,0);
  51         if(s == -1) return 0;
  52         close(s);
  53         return 1;
  54 }
  55 #endif
  56
  57
  58 char * mpd_sanitizeArg(const char * arg) {
  59         size_t i;
  60         int count=0;
  61         char * ret;
  62
  63         for(i=0;i<strlen(arg);i++) {
  64                 if(arg[i]=='"' || arg[i]=='\\') count++;
  65         }
  66
  67         ret = malloc(strlen(arg)+count+1);
  68
  69         count = 0;
  70         for(i=0;i<strlen(arg)+1;i++) {
  71                 if(arg[i]=='"' || arg[i]=='\\') {
  72                         ret[i+count] = '\\';
  73                         count++;
  74                 }
  75                 ret[i+count] = arg[i];
  76         }
  77
  78         return ret;
  79 }
  80
  81 mpd_ReturnElement * mpd_newReturnElement(const char * name, const char * value)
  82 {
  83         mpd_ReturnElement * ret = malloc(sizeof(mpd_ReturnElement));
  84
  85         ret->name = strdup(name);
  86         ret->value = strdup(value);
  87
  88         return ret;
  89 }
  90
  91 void mpd_freeReturnElement(mpd_ReturnElement * re) {
  92         free(re->name);
  93         free(re->value);
  94         free(re);
  95 }
  96
  97 void mpd_setConnectionTimeout(mpd_Connection * connection, float timeout) {
  98                 connection->timeout.tv_sec = (int)timeout;
  99                 connection->timeout.tv_usec = (int)(timeout*1e6 -
 100                                 connection->timeout.tv_sec*1000000+0.5);
 101 }
 102
 103 mpd_Connection * mpd_newConnection(const char * host, int port, float timeout) {
 104         int err;
 105         struct hostent * he;
 106         struct sockaddr * dest;
 107         socklen_t destlen;
 108         struct sockaddr_in sin;
 109         char * rt;
 110         char * output;
 111         mpd_Connection * connection = malloc(sizeof(mpd_Connection));
 112         struct timeval tv;
 113         fd_set fds;
 114 #ifdef MPD_HAVE_IPV6
 115         struct sockaddr_in6 sin6;
 116 #endif
 117         strcpy(connection->buffer,"");
 118         connection->buflen = 0;
 119         connection->bufstart = 0;
 120         strcpy(connection->errorStr,"");
 121         connection->error = 0;
 122         connection->doneProcessing = 0;
 123         connection->commandList = 0;
 124         connection->returnElement = NULL;
 125
 126         if(!(he=gethostbyname(host))) {
 127                 snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
 128                                 "host \"%s\" not found",host);
 129                 connection->error = MPD_ERROR_UNKHOST;
 130                 return connection;
 131         }
 132
 133         memset(&sin,0,sizeof(struct sockaddr_in));
 134         /*dest.sin_family = he->h_addrtype;*/
 135         sin.sin_family = AF_INET;
 136         sin.sin_port = htons(port);
 137 #ifdef MPD_HAVE_IPV6
 138         memset(&sin6,0,sizeof(struct sockaddr_in6));
 139         sin6.sin6_family = AF_INET6;
 140         sin6.sin6_port = htons(port);
 141 #endif
 142         switch(he->h_addrtype) {
 143         case AF_INET:
 144                 memcpy((char *)&sin.sin_addr.s_addr,(char *)he->h_addr,
 145                                 he->h_length);
 146                 dest = (struct sockaddr *)&sin;
 147                 destlen = sizeof(struct sockaddr_in);
 148                 break;
 149 #ifdef MPD_HAVE_IPV6
 150         case AF_INET6:
 151                 if(!mpd_ipv6Supported()) {
 152                         strcpy(connection->errorStr,"no IPv6 suuport but a "
 153                                         "IPv6 address found\n");
 154                         connection->error = MPD_ERROR_SYSTEM;
 155                         return connection;
 156                 }
 157                 memcpy((char *)&sin6.sin6_addr.s6_addr,(char *)he->h_addr,
 158                                 he->h_length);
 159                 dest = (struct sockaddr *)&sin6;
 160                 destlen = sizeof(struct sockaddr_in6);
 161                 break;
 162 #endif
 163         default:
 164                 strcpy(connection->errorStr,"address type is not IPv4 or "
 165                                 "IPv6\n");
 166                 connection->error = MPD_ERROR_SYSTEM;
 167                 return connection;
 168                 break;
 169         }
 170
 171         if((connection->sock = socket(dest->sa_family,SOCK_STREAM,0))<0) {
 172                 strcpy(connection->errorStr,"problems creating socket");
 173                 connection->error = MPD_ERROR_SYSTEM;
 174                 return connection;
 175         }
 176
 177         /* connect stuff */
 178         {
 179 #ifdef SO_RCVTIMEO
 180                 struct timeval rcvoldto;
 181                 struct timeval sndoldto;
 182                 socklen_t oldlen = sizeof(struct timeval);
 183
 184                 mpd_setConnectionTimeout(connection,timeout);
 185
 186                 tv.tv_sec = connection->timeout.tv_sec;
 187                 tv.tv_usec = connection->timeout.tv_usec;
 188
 189                 if(getsockopt(connection->sock,SOL_SOCKET,SO_RCVTIMEO,&rcvoldto,
 190                                         &oldlen)<0 ||
 191                                 getsockopt(connection->sock,SOL_SOCKET,
 192                                         SO_SNDTIMEO,&sndoldto,&oldlen)<0)
 193                 {
 194                         strcpy(connection->errorStr,"problems getting socket "
 195                                         "timeout\n");
 196                         connection->error = MPD_ERROR_SYSTEM;
 197                         return connection;
 198                 }
 199                 if(setsockopt(connection->sock,SOL_SOCKET,SO_RCVTIMEO,&tv,
 200                                         sizeof(struct timeval))<0 ||
 201                                 setsockopt(connection->sock,SOL_SOCKET,
 202                                         SO_SNDTIMEO,&tv,
 203                                         sizeof(struct timeval))<0)
 204                 {
 205                         strcpy(connection->errorStr,"problems setting socket "
 206                                         "timeout\n");
 207                         connection->error = MPD_ERROR_SYSTEM;
 208                         return connection;
 209                 }
 210 #endif
 211                 if(connect(connection->sock,dest,destlen)<0) {
 212                         snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
 213                                         "problems connecting to \"%s\" on port"
 214                                         " %i",host,port);
 215                         connection->error = MPD_ERROR_CONNPORT;
 216                         return connection;
 217                 }
 218 #ifdef SO_RCVTIMEO
 219                 if(setsockopt(connection->sock,SOL_SOCKET,SO_SNDTIMEO,&rcvoldto,
 220                                         sizeof(struct timeval))<0 ||
 221                                 setsockopt(connection->sock,SOL_SOCKET,
 222                                         SO_SNDTIMEO,&sndoldto,
 223                                         sizeof(struct timeval))<0)
 224                 {
 225                         strcpy(connection->errorStr,"problems setting socket "
 226                                         "timeout\n");
 227                         connection->error = MPD_ERROR_SYSTEM;
 228                         return connection;
 229                 }
 230 #endif
 231         }
 232
 233         while(!(rt = strstr(connection->buffer,"\n"))) {
 234                 tv.tv_sec = connection->timeout.tv_sec;
 235                 tv.tv_usec = connection->timeout.tv_usec;
 236                 FD_ZERO(&fds);
 237                 FD_SET(connection->sock,&fds);
 238                 if((err = select(connection->sock+1,&fds,NULL,NULL,&tv)) == 1) {
 239                         int readed;
 240                         readed = recv(connection->sock,
 241                                 &(connection->buffer[connection->buflen]),
 242                                 MPD_BUFFER_MAX_LENGTH-connection->buflen,0);
 243                         if(readed<=0) {
 244                                 snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
 245                                         "problems getting a response from"
 246                                         " \"%s\" on port %i",host,
 247                                         port);
 248                                 connection->error = MPD_ERROR_NORESPONSE;
 249                                 return connection;
 250                         }
 251                         connection->buflen+=readed;
 252                         connection->buffer[connection->buflen] = '\0';
 253                         tv.tv_sec = connection->timeout.tv_sec;
 254                         tv.tv_usec = connection->timeout.tv_usec;
 255                 }
 256                 else if(err<0 && errno==EINTR) continue;
 257                 else {
 258                         snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
 259                                 "timeout in attempting to get a response from"
 260                                  " \"%s\" on port %i",host,port);
 261                         connection->error = MPD_ERROR_NORESPONSE;
 262                         return connection;
 263                 }
 264         }
 265
 266         *rt = '\0';
 267         output = strdup(connection->buffer);
 268         strcpy(connection->buffer,rt+1);
 269         connection->buflen = strlen(connection->buffer);
 270
 271         if(strncmp(output,MPD_WELCOME_MESSAGE,strlen(MPD_WELCOME_MESSAGE))) {
 272                 free(output);
 273                 snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
 274                                 "mpd not running on port %i on host \"%s\"",
 275                                 port,host);
 276                 connection->error = MPD_ERROR_NOTMPD;
 277                 return connection;
 278         }
 279
 280         {
 281                 char * test;
 282                 char * version[3];
 283                 char * tmp = &output[strlen(MPD_WELCOME_MESSAGE)];
 284                 char * search = ".";
 285                 int i;
 286
 287                 for(i=0;i<3;i++) {
 288                         char * tok;
 289                         if(i==3) search = " ";
 290                         version[i] = strtok_r(tmp,search,&tok);
 291                         if(!version[i]) {
 292                                 free(output);
 293                                 snprintf(connection->errorStr,
 294                                         MPD_BUFFER_MAX_LENGTH,
 295                                         "error parsing version number at "
 296                                         "\"%s\"",
 297                                         &output[strlen(MPD_WELCOME_MESSAGE)]);
 298                                 connection->error = MPD_ERROR_NOTMPD;
 299                                 return connection;
 300                         }
 301                         connection->version[i] = strtol(version[i],&test,10);
 302                         if(version[i]==test || *test!='\0') {
 303                                 free(output);
 304                                 snprintf(connection->errorStr,
 305                                         MPD_BUFFER_MAX_LENGTH,
 306                                         "error parsing version number at "
 307                                         "\"%s\"",
 308                                         &output[strlen(MPD_WELCOME_MESSAGE)]);
 309                                 connection->error = MPD_ERROR_NOTMPD;
 310                                 return connection;
 311                         }
 312                         tmp = NULL;
 313                 }
 314         }
 315
 316         free(output);
 317
 318         connection->doneProcessing = 1;
 319
 320         return connection;
 321 }
 322
 323 void mpd_clearError(mpd_Connection * connection) {
 324         connection->error = 0;
 325         connection->errorStr[0] = '\0';
 326 }
 327
 328 void mpd_closeConnection(mpd_Connection * connection) {
 329         close(connection->sock);
 330         if(connection->returnElement) free(connection->returnElement);
 331         free(connection);
 332 }
 333
 334 void mpd_executeCommand(mpd_Connection * connection, char * command) {
 335         int ret;
 336         struct timeval tv;
 337         fd_set fds;
 338         char * commandPtr = command;
 339         int commandLen = strlen(command);
 340
 341         if(!connection->doneProcessing && !connection->commandList) {
 342                 strcpy(connection->errorStr,"not done processing current command");
 343                 connection->error = 1;
 344                 return;
 345         }
 346
 347         mpd_clearError(connection);
 348
 349         FD_ZERO(&fds);
 350         FD_SET(connection->sock,&fds);
 351         tv.tv_sec = connection->timeout.tv_sec;
 352         tv.tv_usec = connection->timeout.tv_usec;
 353
 354         while((ret = select(connection->sock+1,NULL,&fds,NULL,&tv)==1) ||
 355                         (ret==-1 && errno==EINTR)) {
 356                 ret = send(connection->sock,commandPtr,commandLen,
 357                                 MSG_DONTWAIT);
 358                 if(ret<=0)
 359                 {
 360                         if(ret==EAGAIN || ret==EINTR) continue;
 361                         snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
 362                                 "problems giving command \"%s\"",command);
 363                         connection->error = MPD_ERROR_SENDING;
 364                         return;
 365                 }
 366                 else {
 367                         commandPtr+=ret;
 368                         commandLen-=ret;
 369                 }
 370
 371                 if(commandLen<=0) break;
 372         }
 373
 374         if(commandLen>0) {
 375                 perror("");
 376                 snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
 377                         "timeout sending command \"%s\"",command);
 378                 connection->error = MPD_ERROR_TIMEOUT;
 379                 return;
 380         }
 381
 382         if(!connection->commandList) connection->doneProcessing = 0;
 383 }
 384
 385 void mpd_getNextReturnElement(mpd_Connection * connection) {
 386         char * output = NULL;
 387         char * rt = NULL;
 388         char * name = NULL;
 389         char * value = NULL;
 390         fd_set fds;
 391         struct timeval tv;
 392         char * tok = NULL;
 393         int readed;
 394         char * bufferCheck = NULL;
 395         int err;
 396
 397         if(connection->returnElement) mpd_freeReturnElement(connection->returnElement);
 398         connection->returnElement = NULL;
 399
 400         if(connection->doneProcessing) {
 401                 strcpy(connection->errorStr,"already done processing current command");
 402                 connection->error = 1;
 403                 return;
 404         }
 405
 406         bufferCheck = connection->buffer+connection->bufstart;
 407         while(connection->bufstart>=connection->buflen ||
 408                         !(rt = strstr(bufferCheck,"\n"))) {
 409                 if(connection->buflen>=MPD_BUFFER_MAX_LENGTH) {
 410                         memmove(connection->buffer,
 411                                         connection->buffer+
 412                                         connection->bufstart,
 413                                         connection->buflen-
 414                                         connection->bufstart+1);
 415                         bufferCheck-=connection->bufstart;
 416                         connection->buflen-=connection->bufstart;
 417                         connection->bufstart = 0;
 418                 }
 419                 if(connection->buflen>=MPD_BUFFER_MAX_LENGTH) {
 420                         strcpy(connection->errorStr,"buffer overrun");
 421                         connection->error = MPD_ERROR_BUFFEROVERRUN;
 422                         connection->doneProcessing = 1;
 423                         return;
 424                 }
 425                 bufferCheck+=connection->buflen-connection->bufstart;
 426                 tv.tv_sec = connection->timeout.tv_sec;
 427                 tv.tv_usec = connection->timeout.tv_usec;
 428                 FD_ZERO(&fds);
 429                 FD_SET(connection->sock,&fds);
 430                 if((err = select(connection->sock+1,&fds,NULL,NULL,&tv) == 1)) {
 431                         readed = recv(connection->sock,
 432                                 connection->buffer+connection->buflen,
 433                                 MPD_BUFFER_MAX_LENGTH-connection->buflen,
 434                                 MSG_DONTWAIT);
 435                         if(readed<0 && (errno==EAGAIN || errno==EINTR)) {
 436                                 continue;
 437                         }
 438                         if(readed<=0) {
 439                                 strcpy(connection->errorStr,"connection"
 440                                         " closed");
 441                                 connection->error = MPD_ERROR_CONNCLOSED;
 442                                 connection->doneProcessing = 1;
 443                                 return;
 444                         }
 445                         connection->buflen+=readed;
 446                         connection->buffer[connection->buflen] = '\0';
 447                 }
 448                 else if(err<0 && errno==EINTR) continue;
 449                 else {
 450                         strcpy(connection->errorStr,"connection timeout");
 451                         connection->error = MPD_ERROR_TIMEOUT;
 452                         connection->doneProcessing = 1;
 453                         return;
 454                 }
 455         }
 456
 457         *rt = '\0';
 458         output = connection->buffer+connection->bufstart;
 459         connection->bufstart = rt - connection->buffer + 1;
 460
 461         if(strcmp(output,"OK")==0) {
 462                 connection->doneProcessing = 1;
 463                 return;
 464         }
 465         if(strncmp(output,"ACK",strlen("ACK"))==0) {
 466                 char * test;
 467                 char * needle;
 468                 int val;
 469
 470                 strcpy(connection->errorStr, output);
 471                 connection->error = MPD_ERROR_ACK;
 472                 connection->errorCode = MPD_ERROR_CODE_UNK;
 473                 connection->errorAt = MPD_ERROR_AT_UNK;
 474                 connection->doneProcessing = 1;
 475
 476                 needle = strchr(output, '[');
 477                 if(!needle) return;
 478                 val = strtol(needle, &test, 10);
 479                 if(*test != '@') return;
 480                 connection->errorCode = val;
 481                 val = strtol(test+1, &test, 10);
 482                 if(*test != ']') return;
 483                 connection->errorAt = val;
 484                 return;
 485         }
 486
 487         name = strtok_r(output,":",&tok);
 488         if(name && (value = strtok_r(NULL,"",&tok)) && value[0]==' ') {
 489                 connection->returnElement = mpd_newReturnElement(name,&(value[1]));
 490         }
 491         else {
 492                 if(!name || !value) {
 493                         snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
 494                                         "error parsing: %s",output);
 495                 }
 496                 else {
 497                         snprintf(connection->errorStr,MPD_BUFFER_MAX_LENGTH,
 498                                         "error parsing: %s:%s",name,value);
 499                 }
 500                 connection->errorStr[MPD_BUFFER_MAX_LENGTH] = '\0';
 501                 connection->error = 1;
 502         }
 503 }
 504
 505 void mpd_finishCommand(mpd_Connection * connection) {
 506         while(!connection->doneProcessing) mpd_getNextReturnElement(connection);
 507 }
 508
 509 mpd_Status * mpd_getStatus(mpd_Connection * connection) {
 510         mpd_Status * status;
 511
 512         mpd_executeCommand(connection,"status\n");
 513
 514         if(connection->error) return NULL;
 515
 516         status = malloc(sizeof(mpd_Status));
 517         status->volume = -1;
 518         status->repeat = 0;
 519         status->random = 0;
 520         status->playlist = -1;
 521         status->playlistLength = -1;
 522         status->state = -1;
 523         status->song = 0;
 524         status->elapsedTime = 0;
 525         status->totalTime = 0;
 526         status->bitRate = 0;
 527         status->sampleRate = 0;
 528         status->bits = 0;
 529         status->channels = 0;
 530         status->crossfade = -1;
 531         status->error = NULL;
 532         status->updatingDb = 0;
 533
 534         mpd_getNextReturnElement(connection);
 535         if(connection->error) {
 536                 free(status);
 537                 return NULL;
 538         }
 539         while(connection->returnElement) {
 540                 mpd_ReturnElement * re = connection->returnElement;
 541                 if(strcmp(re->name,"volume")==0) {
 542                         status->volume = atoi(re->value);
 543                 }
 544                 else if(strcmp(re->name,"repeat")==0) {
 545                         status->repeat = atoi(re->value);
 546                 }
 547                 else if(strcmp(re->name,"random")==0) {
 548                         status->random = atoi(re->value);
 549                 }
 550                 else if(strcmp(re->name,"playlist")==0) {
 551                         status->playlist = strtol(re->value,NULL,10);
 552                 }
 553                 else if(strcmp(re->name,"playlistlength")==0) {
 554                         status->playlistLength = atoi(re->value);
 555                 }
 556                 else if(strcmp(re->name,"bitrate")==0) {
 557                         status->bitRate = atoi(re->value);
 558                 }
 559                 else if(strcmp(re->name,"state")==0) {
 560                         if(strcmp(re->value,"play")==0) {
 561                                 status->state = MPD_STATUS_STATE_PLAY;
 562                         }
 563                         else if(strcmp(re->value,"stop")==0) {
 564                                 status->state = MPD_STATUS_STATE_STOP;
 565                         }
 566                         else if(strcmp(re->value,"pause")==0) {
 567                                 status->state = MPD_STATUS_STATE_PAUSE;
 568                         }
 569                         else {
 570                                 status->state = MPD_STATUS_STATE_UNKNOWN;
 571                         }
 572                 }
 573                 else if(strcmp(re->name,"song")==0) {
 574                         status->song = atoi(re->value);
 575                 }
 576                 else if(strcmp(re->name,"time")==0) {
 577                         char * tok;
 578                         char * copy;
 579                         char * temp;
 580                         copy = strdup(re->value);
 581                         temp = strtok_r(copy,":",&tok);
 582                         if(temp) {
 583                                 status->elapsedTime = atoi(temp);
 584                                 temp = strtok_r(NULL,"",&tok);
 585                                 if(temp) status->totalTime = atoi(temp);
 586                         }
 587                         free(copy);
 588                 }
 589                 else if(strcmp(re->name,"error")==0) {
 590                         status->error = strdup(re->value);
 591                 }
 592                 else if(strcmp(re->name,"xfade")==0) {
 593                         status->crossfade = atoi(re->value);
 594                 }
 595                 else if(strcmp(re->name,"updating_db")==0) {
 596                         status->updatingDb = atoi(re->value);
 597                 }
 598                 else if(strcmp(re->name,"audio")==0) {
 599                         char * tok;
 600                         char * copy;
 601                         char * temp;
 602                         copy = strdup(re->value);
 603                         temp = strtok_r(copy,":",&tok);
 604                         if(temp) {
 605                                 status->sampleRate = atoi(temp);
 606                                 temp = strtok_r(NULL,":",&tok);
 607                                 if(temp) {
 608                                         status->bits = atoi(temp);
 609                                         temp = strtok_r(NULL,"",&tok);
 610                                         if(temp) status->channels = atoi(temp);
 611                                 }
 612                         }
 613                         free(copy);
 614                 }
 615
 616                 mpd_getNextReturnElement(connection);
 617                 if(connection->error) {
 618                         free(status);
 619                         return NULL;
 620                 }
 621         }
 622
 623         if(connection->error) {
 624                 free(status);
 625                 return NULL;
 626         }
 627         else if(status->state<0) {
 628                 strcpy(connection->errorStr,"state not found");
 629                 connection->error = 1;
 630                 free(status);
 631                 return NULL;
 632         }
 633
 634         return status;
 635 }
 636
 637 void mpd_freeStatus(mpd_Status * status) {
 638         if(status->error) free(status->error);
 639         free(status);
 640 }
 641
 642 mpd_Stats * mpd_getStats(mpd_Connection * connection) {
 643         mpd_Stats * stats;
 644
 645         mpd_executeCommand(connection,"stats\n");
 646
 647         if(connection->error) return NULL;
 648
 649         stats = malloc(sizeof(mpd_Stats));
 650         stats->numberOfArtists = 0;
 651         stats->numberOfAlbums = 0;
 652         stats->numberOfSongs = 0;
 653         stats->uptime = 0;
 654         stats->dbUpdateTime = 0;
 655         stats->playTime = 0;
 656         stats->dbPlayTime = 0;
 657
 658         mpd_getNextReturnElement(connection);
 659         if(connection->error) {
 660                 free(stats);
 661                 return NULL;
 662         }
 663         while(connection->returnElement) {
 664                 mpd_ReturnElement * re = connection->returnElement;
 665                 if(strcmp(re->name,"artists")==0) {
 666                         stats->numberOfArtists = atoi(re->value);
 667                 }
 668                 else if(strcmp(re->name,"albums")==0) {
 669                         stats->numberOfAlbums = atoi(re->value);
 670                 }
 671                 else if(strcmp(re->name,"songs")==0) {
 672                         stats->numberOfSongs = atoi(re->value);
 673                 }
 674                 else if(strcmp(re->name,"uptime")==0) {
 675                         stats->uptime = strtol(re->value,NULL,10);
 676                 }
 677                 else if(strcmp(re->name,"db_update")==0) {
 678                         stats->dbUpdateTime = strtol(re->value,NULL,10);
 679                 }
 680                 else if(strcmp(re->name,"playtime")==0) {
 681                         stats->playTime = strtol(re->value,NULL,10);
 682                 }
 683                 else if(strcmp(re->name,"db_playtime")==0) {
 684                         stats->dbPlayTime = strtol(re->value,NULL,10);
 685                 }
 686
 687                 mpd_getNextReturnElement(connection);
 688                 if(connection->error) {
 689                         free(stats);
 690                         return NULL;
 691                 }
 692         }
 693
 694         if(connection->error) {
 695                 free(stats);
 696                 return NULL;
 697         }
 698
 699         return stats;
 700 }
 701
 702 void mpd_freeStats(mpd_Stats * stats) {
 703         free(stats);
 704 }
 705
 706 void mpd_initSong(mpd_Song * song) {
 707         song->file = NULL;
 708         song->artist = NULL;
 709         song->album = NULL;
 710         song->track = NULL;
 711         song->title = NULL;
 712         song->name = NULL;
 713         song->time = MPD_SONG_NO_TIME;
 714         song->num = MPD_SONG_NO_NUM;
 715 }
 716
 717 void mpd_finishSong(mpd_Song * song) {
 718         if(song->file) free(song->file);
 719         if(song->artist) free(song->artist);
 720         if(song->album) free(song->album);
 721         if(song->title) free(song->title);
 722         if(song->track) free(song->track);
 723         if(song->name) free(song->name);
 724 }
 725
 726 mpd_Song * mpd_newSong() {
 727         mpd_Song * ret = malloc(sizeof(mpd_Song));
 728
 729         mpd_initSong(ret);
 730
 731         return ret;
 732 }
 733
 734 void mpd_freeSong(mpd_Song * song) {
 735         mpd_finishSong(song);
 736         free(song);
 737 }
 738
 739 mpd_Song * mpd_songDup(mpd_Song * song) {
 740         mpd_Song * ret = mpd_newSong();
 741
 742         if(song->file) ret->file = strdup(song->file);
 743         if(song->artist) ret->artist = strdup(song->artist);
 744         if(song->album) ret->album = strdup(song->album);
 745         if(song->title) ret->title = strdup(song->title);
 746         if(song->track) ret->track = strdup(song->track);
 747         if(song->name) ret->name = strdup(song->name);
 748         ret->time = song->time;
 749         ret->num = song->num;
 750
 751         return ret;
 752 }
 753
 754 void mpd_initDirectory(mpd_Directory * directory) {
 755         directory->path = NULL;
 756 }
 757
 758 void mpd_finishDirectory(mpd_Directory * directory) {
 759         if(directory->path) free(directory->path);
 760 }
 761
 762 mpd_Directory * mpd_newDirectory () {
 763         mpd_Directory * directory = malloc(sizeof(mpd_Directory));;
 764
 765         mpd_initDirectory(directory);
 766
 767         return directory;
 768 }
 769
 770 void mpd_freeDirectory(mpd_Directory * directory) {
 771         mpd_finishDirectory(directory);
 772
 773         free(directory);
 774 }
 775
 776 mpd_Directory * mpd_directoryDup(mpd_Directory * directory) {
 777         mpd_Directory * ret = mpd_newDirectory();
 778
 779         if(directory->path) ret->path = strdup(directory->path);
 780
 781         return ret;
 782 }
 783
 784 void mpd_initPlaylistFile(mpd_PlaylistFile * playlist) {
 785         playlist->path = NULL;
 786 }
 787
 788 void mpd_finishPlaylistFile(mpd_PlaylistFile * playlist) {
 789         if(playlist->path) free(playlist->path);
 790 }
 791
 792 mpd_PlaylistFile * mpd_newPlaylistFile() {
 793         mpd_PlaylistFile * playlist = malloc(sizeof(mpd_PlaylistFile));
 794
 795         mpd_initPlaylistFile(playlist);
 796
 797         return playlist;
 798 }
 799
 800 void mpd_freePlaylistFile(mpd_PlaylistFile * playlist) {
 801         mpd_finishPlaylistFile(playlist);
 802         free(playlist);
 803 }
 804
 805 mpd_PlaylistFile * mpd_playlistFileDup(mpd_PlaylistFile * playlist) {
 806         mpd_PlaylistFile * ret = mpd_newPlaylistFile();
 807
 808         if(playlist->path) ret->path = strdup(playlist->path);
 809
 810         return ret;
 811 }
 812
 813 void mpd_initInfoEntity(mpd_InfoEntity * entity) {
 814         entity->info.directory = NULL;
 815 }
 816
 817 void mpd_finishInfoEntity(mpd_InfoEntity * entity) {
 818         if(entity->info.directory) {
 819                 if(entity->type == MPD_INFO_ENTITY_TYPE_DIRECTORY) {
 820                         mpd_freeDirectory(entity->info.directory);
 821                 }
 822                 else if(entity->type == MPD_INFO_ENTITY_TYPE_SONG) {
 823                         mpd_freeSong(entity->info.song);
 824                 }
 825                 else if(entity->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE) {
 826                         mpd_freePlaylistFile(entity->info.playlistFile);
 827                 }
 828         }
 829 }
 830
 831 mpd_InfoEntity * mpd_newInfoEntity() {
 832         mpd_InfoEntity * entity = malloc(sizeof(mpd_InfoEntity));
 833
 834         mpd_initInfoEntity(entity);
 835
 836         return entity;
 837 }
 838
 839 void mpd_freeInfoEntity(mpd_InfoEntity * entity) {
 840         mpd_finishInfoEntity(entity);
 841         free(entity);
 842 }
 843
 844 void mpd_sendInfoCommand(mpd_Connection * connection, char * command) {
 845         mpd_executeCommand(connection,command);
 846 }
 847
 848 mpd_InfoEntity * mpd_getNextInfoEntity(mpd_Connection * connection) {
 849         mpd_InfoEntity * entity = NULL;
 850
 851         if(connection->doneProcessing) return NULL;
 852
 853         if(!connection->returnElement) mpd_getNextReturnElement(connection);
 854
 855         if(connection->returnElement) {
 856                 if(strcmp(connection->returnElement->name,"file")==0) {
 857                         entity = mpd_newInfoEntity();
 858                         entity->type = MPD_INFO_ENTITY_TYPE_SONG;
 859                         entity->info.song = mpd_newSong();
 860                         entity->info.song->file =
 861                                 strdup(connection->returnElement->value);
 862                 }
 863                 else if(strcmp(connection->returnElement->name,
 864                                         "directory")==0) {
 865                         entity = mpd_newInfoEntity();
 866                         entity->type = MPD_INFO_ENTITY_TYPE_DIRECTORY;
 867                         entity->info.directory = mpd_newDirectory();
 868                         entity->info.directory->path =
 869                                 strdup(connection->returnElement->value);
 870                 }
 871                 else if(strcmp(connection->returnElement->name,"playlist")==0) {
 872                         entity = mpd_newInfoEntity();
 873                         entity->type = MPD_INFO_ENTITY_TYPE_PLAYLISTFILE;
 874                         entity->info.playlistFile = mpd_newPlaylistFile();
 875                         entity->info.playlistFile->path =
 876                                 strdup(connection->returnElement->value);
 877                 }
 878                 else {
 879                         connection->error = 1;
 880                         strcpy(connection->errorStr,"problem parsing song info");
 881                         return NULL;
 882                 }
 883         }
 884         else return NULL;
 885
 886         mpd_getNextReturnElement(connection);
 887         while(connection->returnElement) {
 888                 mpd_ReturnElement * re = connection->returnElement;
 889
 890                 if(strcmp(re->name,"file")==0) return entity;
 891                 else if(strcmp(re->name,"directory")==0) return entity;
 892                 else if(strcmp(re->name,"playlist")==0) return entity;
 893
 894                 if(entity->type == MPD_INFO_ENTITY_TYPE_SONG &&
 895                                 strlen(re->value)) {
 896                         if(!entity->info.song->artist &&
 897                                         strcmp(re->name,"Artist")==0) {
 898                                 entity->info.song->artist = strdup(re->value);
 899                         }
 900                         else if(!entity->info.song->album &&
 901                                         strcmp(re->name,"Album")==0) {
 902                                 entity->info.song->album = strdup(re->value);
 903                         }
 904                         else if(!entity->info.song->title &&
 905                                         strcmp(re->name,"Title")==0) {
 906                                 entity->info.song->title = strdup(re->value);
 907                         }
 908                         else if(!entity->info.song->track &&
 909                                         strcmp(re->name,"Track")==0) {
 910                                 entity->info.song->track = strdup(re->value);
 911                         }
 912                         else if(!entity->info.song->name &&
 913                                         strcmp(re->name,"Name")==0) {
 914                                 entity->info.song->name = strdup(re->value);
 915                         }
 916                         else if(entity->info.song->time==MPD_SONG_NO_TIME &&
 917                                         strcmp(re->name,"Time")==0) {
 918                                 entity->info.song->time = atoi(re->value);
 919                         }
 920                         else if(entity->info.song->num==MPD_SONG_NO_NUM &&
 921                                         strcmp(re->name,"Num")==0) {
 922                                 entity->info.song->num = atoi(re->value);
 923                         }
 924                 }
 925                 else if(entity->type == MPD_INFO_ENTITY_TYPE_DIRECTORY) {
 926                 }
 927                 else if(entity->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE) {
 928                 }
 929
 930                 mpd_getNextReturnElement(connection);
 931         }
 932
 933         return entity;
 934 }
 935
 936 char * mpd_getNextReturnElementNamed(mpd_Connection * connection,
 937                 const char * name)
 938 {
 939         if(connection->doneProcessing) return NULL;
 940
 941         mpd_getNextReturnElement(connection);
 942         while(connection->returnElement) {
 943                 mpd_ReturnElement * re = connection->returnElement;
 944
 945                 if(strcmp(re->name,name)==0) return strdup(re->value);
 946                 mpd_getNextReturnElement(connection);
 947         }
 948
 949         return NULL;
 950 }
 951
 952 char * mpd_getNextArtist(mpd_Connection * connection) {
 953         return mpd_getNextReturnElementNamed(connection,"Artist");
 954 }
 955
 956 char * mpd_getNextAlbum(mpd_Connection * connection) {
 957         return mpd_getNextReturnElementNamed(connection,"Album");
 958 }
 959
 960 void mpd_sendPlaylistInfoCommand(mpd_Connection * connection, int songNum) {
 961         char * string = malloc(strlen("playlistinfo")+25);
 962         sprintf(string,"playlistinfo \"%i\"\n",songNum);
 963         mpd_sendInfoCommand(connection,string);
 964         free(string);
 965 }
 966
 967 void mpd_sendPlChangesCommand(mpd_Connection * connection, long long playlist) {
 968         char * string = malloc(strlen("plchanges")+25);
 969         sprintf(string,"plchanges \"%i\"\n",playlist);
 970         mpd_sendInfoCommand(connection,string);
 971         free(string);
 972 }
 973
 974 void mpd_sendListallCommand(mpd_Connection * connection, const char * dir) {
 975         char * sDir = mpd_sanitizeArg(dir);
 976         char * string = malloc(strlen("listall")+strlen(sDir)+5);
 977         sprintf(string,"listall \"%s\"\n",sDir);
 978         mpd_sendInfoCommand(connection,string);
 979         free(string);
 980         free(sDir);
 981 }
 982
 983 void mpd_sendListallInfoCommand(mpd_Connection * connection, const char * dir) {
 984         char * sDir = mpd_sanitizeArg(dir);
 985         char * string = malloc(strlen("listallinfo")+strlen(sDir)+5);
 986         sprintf(string,"listallinfo \"%s\"\n",sDir);
 987         mpd_sendInfoCommand(connection,string);
 988         free(string);
 989         free(sDir);
 990 }
 991
 992 void mpd_sendLsInfoCommand(mpd_Connection * connection, const char * dir) {
 993         char * sDir = mpd_sanitizeArg(dir);
 994         char * string = malloc(strlen("lsinfo")+strlen(sDir)+5);
 995         sprintf(string,"lsinfo \"%s\"\n",sDir);
 996         mpd_sendInfoCommand(connection,string);
 997         free(string);
 998         free(sDir);
 999 }
1000
1001 void mpd_sendSearchCommand(mpd_Connection * connection, int table,
1002                 const char * str)
1003 {
1004         char st[10];
1005         char * string;
1006         char * sanitStr = mpd_sanitizeArg(str);
1007         if(table == MPD_TABLE_ARTIST) strcpy(st,"artist");
1008         else if(table == MPD_TABLE_ALBUM) strcpy(st,"album");
1009         else if(table == MPD_TABLE_TITLE) strcpy(st,"title");
1010         else if(table == MPD_TABLE_FILENAME) strcpy(st,"filename");
1011         else {
1012                 connection->error = 1;
1013                 strcpy(connection->errorStr,"unknown table for search");
1014                 return;
1015         }
1016         string = malloc(strlen("search")+strlen(sanitStr)+strlen(st)+6);
1017         sprintf(string,"search %s \"%s\"\n",st,sanitStr);
1018         mpd_sendInfoCommand(connection,string);
1019         free(string);
1020         free(sanitStr);
1021 }
1022
1023 void mpd_sendFindCommand(mpd_Connection * connection, int table,
1024                 const char * str)
1025 {
1026         char st[10];
1027         char * string;
1028         char * sanitStr = mpd_sanitizeArg(str);
1029         if(table == MPD_TABLE_ARTIST) strcpy(st,"artist");
1030         else if(table == MPD_TABLE_ALBUM) strcpy(st,"album");
1031         else if(table == MPD_TABLE_TITLE) strcpy(st,"title");
1032         else {
1033                 connection->error = 1;
1034                 strcpy(connection->errorStr,"unknown table for find");
1035                 return;
1036         }
1037         string = malloc(strlen("find")+strlen(sanitStr)+strlen(st)+6);
1038         sprintf(string,"find %s \"%s\"\n",st,sanitStr);
1039         mpd_sendInfoCommand(connection,string);
1040         free(string);
1041         free(sanitStr);
1042 }
1043
1044 void mpd_sendListCommand(mpd_Connection * connection, int table,
1045                 const char * arg1)
1046 {
1047         char st[10];
1048         char * string;
1049         if(table == MPD_TABLE_ARTIST) strcpy(st,"artist");
1050         else if(table == MPD_TABLE_ALBUM) strcpy(st,"album");
1051         else {
1052                 connection->error = 1;
1053                 strcpy(connection->errorStr,"unknown table for list");
1054                 return;
1055         }
1056         if(arg1) {
1057                 char * sanitArg1 = mpd_sanitizeArg(arg1);
1058                 string = malloc(strlen("list")+strlen(sanitArg1)+strlen(st)+6);
1059                 sprintf(string,"list %s \"%s\"\n",st,sanitArg1);
1060                 free(sanitArg1);
1061         }
1062         else {
1063                 string = malloc(strlen("list")+strlen(st)+3);
1064                 sprintf(string,"list %s\n",st);
1065         }
1066         mpd_sendInfoCommand(connection,string);
1067         free(string);
1068 }
1069
1070 void mpd_sendAddCommand(mpd_Connection * connection, const char * file) {
1071         char * sFile = mpd_sanitizeArg(file);
1072         char * string = malloc(strlen("add")+strlen(sFile)+5);
1073         sprintf(string,"add \"%s\"\n",sFile);
1074         mpd_executeCommand(connection,string);
1075         free(string);
1076         free(sFile);
1077 }
1078
1079 void mpd_sendDeleteCommand(mpd_Connection * connection, int songNum) {
1080         char * string = malloc(strlen("delete")+25);
1081         sprintf(string,"delete \"%i\"\n",songNum);
1082         mpd_sendInfoCommand(connection,string);
1083         free(string);
1084 }
1085
1086 void mpd_sendSaveCommand(mpd_Connection * connection, const char * name) {
1087         char * sName = mpd_sanitizeArg(name);
1088         char * string = malloc(strlen("save")+strlen(sName)+5);
1089         sprintf(string,"save \"%s\"\n",sName);
1090         mpd_executeCommand(connection,string);
1091         free(string);
1092         free(sName);
1093 }
1094
1095 void mpd_sendLoadCommand(mpd_Connection * connection, const char * name) {
1096         char * sName = mpd_sanitizeArg(name);
1097         char * string = malloc(strlen("load")+strlen(sName)+5);
1098         sprintf(string,"load \"%s\"\n",sName);
1099         mpd_executeCommand(connection,string);
1100         free(string);
1101         free(sName);
1102 }
1103
1104 void mpd_sendRmCommand(mpd_Connection * connection, const char * name) {
1105         char * sName = mpd_sanitizeArg(name);
1106         char * string = malloc(strlen("rm")+strlen(sName)+5);
1107         sprintf(string,"rm \"%s\"\n",sName);
1108         mpd_executeCommand(connection,string);
1109         free(string);
1110         free(sName);
1111 }
1112
1113 void mpd_sendShuffleCommand(mpd_Connection * connection) {
1114         mpd_executeCommand(connection,"shuffle\n");
1115 }
1116
1117 void mpd_sendClearCommand(mpd_Connection * connection) {
1118         mpd_executeCommand(connection,"clear\n");
1119 }
1120
1121 void mpd_sendPlayCommand(mpd_Connection * connection, int songNum) {
1122         char * string = malloc(strlen("play")+25);
1123         sprintf(string,"play \"%i\"\n",songNum);
1124         mpd_sendInfoCommand(connection,string);
1125         free(string);
1126 }
1127
1128 void mpd_sendStopCommand(mpd_Connection * connection) {
1129         mpd_executeCommand(connection,"stop\n");
1130 }
1131
1132 void mpd_sendPauseCommand(mpd_Connection * connection) {
1133         mpd_executeCommand(connection,"pause\n");
1134 }
1135
1136 void mpd_sendNextCommand(mpd_Connection * connection) {
1137         mpd_executeCommand(connection,"next\n");
1138 }
1139
1140 void mpd_sendMoveCommand(mpd_Connection * connection, int from, int to) {
1141         char * string = malloc(strlen("move")+25);
1142         sprintf(string,"move \"%i\" \"%i\"\n",from,to);
1143         mpd_sendInfoCommand(connection,string);
1144         free(string);
1145 }
1146
1147 void mpd_sendSwapCommand(mpd_Connection * connection, int song1, int song2) {
1148         char * string = malloc(strlen("swap")+25);
1149         sprintf(string,"swap \"%i\" \"%i\"\n",song1,song2);
1150         mpd_sendInfoCommand(connection,string);
1151         free(string);
1152 }
1153
1154 void mpd_sendSeekCommand(mpd_Connection * connection, int song, int time) {
1155         char * string = malloc(strlen("seek")+25);
1156         sprintf(string,"seek \"%i\" \"%i\"\n",song,time);
1157         mpd_sendInfoCommand(connection,string);
1158         free(string);
1159 }
1160
1161 void mpd_sendUpdateCommand(mpd_Connection * connection) {
1162         mpd_executeCommand(connection,"update\n");
1163 }
1164
1165 int mpd_getUpdateId(mpd_Connection * connection) {
1166         char * jobid;
1167         int ret = 0;
1168
1169         jobid = mpd_getNextReturnElementNamed(connection,"updating_db");
1170         if(jobid) {
1171                 ret = atoi(jobid);
1172                 free(jobid);
1173         }
1174
1175         return ret;
1176 }
1177
1178 void mpd_sendPrevCommand(mpd_Connection * connection) {
1179         mpd_executeCommand(connection,"previous\n");
1180 }
1181
1182 void mpd_sendRepeatCommand(mpd_Connection * connection, int repeatMode) {
1183         char * string = malloc(strlen("repeat")+25);
1184         sprintf(string,"repeat \"%i\"\n",repeatMode);
1185         mpd_executeCommand(connection,string);
1186         free(string);
1187 }
1188
1189 void mpd_sendRandomCommand(mpd_Connection * connection, int randomMode) {
1190         char * string = malloc(strlen("random")+25);
1191         sprintf(string,"random \"%i\"\n",randomMode);
1192         mpd_executeCommand(connection,string);
1193         free(string);
1194 }
1195
1196 void mpd_sendSetvolCommand(mpd_Connection * connection, int volumeChange) {
1197         char * string = malloc(strlen("setvol")+25);
1198         sprintf(string,"setvol \"%i\"\n",volumeChange);
1199         mpd_executeCommand(connection,string);
1200         free(string);
1201 }
1202
1203 void mpd_sendVolumeCommand(mpd_Connection * connection, int volumeChange) {
1204         char * string = malloc(strlen("volume")+25);
1205         sprintf(string,"volume \"%i\"\n",volumeChange);
1206         mpd_executeCommand(connection,string);
1207         free(string);
1208 }
1209
1210 void mpd_sendCrossfadeCommand(mpd_Connection * connection, int seconds) {
1211         char * string = malloc(strlen("crossfade")+25);
1212         sprintf(string,"crossfade \"%i\"\n",seconds);
1213         mpd_executeCommand(connection,string);
1214         free(string);
1215 }
1216
1217 void mpd_sendPasswordCommand(mpd_Connection * connection, const char * pass) {
1218         char * sPass = mpd_sanitizeArg(pass);
1219         char * string = malloc(strlen("password")+strlen(sPass)+5);
1220         sprintf(string,"password \"%s\"\n",sPass);
1221         mpd_executeCommand(connection,string);
1222         free(string);
1223         free(sPass);
1224 }
1225
1226 void mpd_sendCommandListBegin(mpd_Connection * connection) {
1227         if(connection->commandList) {
1228                 strcpy(connection->errorStr,"already in command list mode");
1229                 connection->error = 1;
1230                 return;
1231         }
1232         connection->commandList = 1;
1233         mpd_executeCommand(connection,"command_list_begin\n");
1234 }
1235
1236 void mpd_sendCommandListEnd(mpd_Connection * connection) {
1237         if(!connection->commandList) {
1238                 strcpy(connection->errorStr,"not in command list mode");
1239                 connection->error = 1;
1240                 return;
1241         }
1242         connection->commandList = 0;
1243         mpd_executeCommand(connection,"command_list_end\n");
1244 }