src/libmpd.c

   1 /* libmpd (high level libmpdclient library)
   2  * Copyright (C) 2004-2009 Qball Cow <qball@sarine.nl>
   3  * Project homepage: http://gmpcwiki.sarine.nl/
   4
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9
  10  * This program 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 General Public License for more details.
  14
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #define __USE_GNU
  23
  24 #include <string.h>
  25 #include <stdarg.h>
  26 #include <config.h>
  27 #include <glib.h>
  28 #include "debug_printf.h"
  29
  30 #include "libmpd.h"
  31 #include "libmpd-internal.h"
  32
  33 static void mpd_free_queue_ob(MpdObj *mi);
  34 static void mpd_server_free_commands(MpdObj *mi);
  35
  36
  37 char *libmpd_version = LIBMPD_VERSION;
  38 #ifndef HAVE_STRNDUP
  39 /**
  40  * Not every platfarm has strndup, so here we have a nice little custom implementation
  41  */
  42 char * strndup(const char *s, size_t n)
  43 {
  44         size_t nAvail;
  45         char *p;
  46
  47         if(!s) {
  48                 return NULL;
  49         }
  50
  51         /*  nAvail = min( strlen(s)+1, n+1 ); */
  52         nAvail=((strlen(s)+1) > (n+1)) ? n+1 : strlen(s)+1;
  53         if(!(p=malloc(nAvail))) {
  54                 return NULL;
  55         }
  56         memcpy(p, s, nAvail);
  57         p[nAvail - 1] = 0;
  58         return p;
  59 }
  60 #endif
  61 /**
  62  * @param state a #MpdServerState to initialize
  63  *
  64  * Initialize #MpdServerState. To stop duplicating code.
  65  */
  66 static void mpd_init_MpdServerState(MpdServerState *state)
  67 {
  68         state->playlistid       = -1;
  69         state->storedplaylistid = -1;
  70         state->state            = -1;
  71         state->songid           = -1;
  72         state->songpos          = -1;
  73         state->dbUpdateTime     = 0;
  74         state->updatingDb       = 0;
  75         state->repeat           = -1;
  76         state->random           = -1;
  77         state->volume           = -2;
  78         state->xfade            = -1;
  79         state->totaltime        = 0;
  80         state->elapsedtime      = 0;
  81         state->bitrate          = 0;
  82         state->samplerate       = 0;
  83         state->channels         = 0;
  84         state->bits             = 0;
  85     state->playlistLength = 0;
  86     state->error[0]            = '\0';
  87
  88 }
  89
  90
  91 static MpdObj * mpd_create()
  92 {
  93         MpdObj * mi = malloc(sizeof(*mi));
  94         if( mi == NULL )
  95         {
  96                 /* should never happen on linux */
  97                 return NULL;
  98         }
  99
 100
 101         /* set default values */
 102         /* we start not connected */
 103         mi->connected = FALSE;
 104         /* port 6600 is the default mpd port */
 105         mi->port = 6600;
 106         /* localhost */
 107         mi->hostname = strdup("localhost");
 108         /* no password */
 109         mi->password = NULL;
 110         /* 1 second timeout */
 111         mi->connection_timeout = 1.0;
 112         /* we have no connection pointer */
 113         mi->connection = NULL;
 114         /* no status */
 115         mi->status = NULL;
 116         /* no stats */
 117         mi->stats = NULL;
 118         mi->error = 0;
 119         mi->error_mpd_code = 0;
 120         mi->error_msg = NULL;
 121         mi->CurrentSong = NULL;
 122         /* info */
 123         mpd_init_MpdServerState(&(mi->CurrentState));
 124         mpd_init_MpdServerState(&(mi->OldState));
 125
 126         /**
 127          * Set signals to NULL
 128          */
 129         /* connection changed signal */
 130         mi->the_connection_changed_callback = NULL;
 131         mi->the_connection_changed_signal_userdata = NULL;
 132
 133         /* status changed */
 134         mi->the_status_changed_callback = NULL;
 135         mi->the_status_changed_signal_userdata = NULL;
 136
 137         /* error callback */
 138         mi->the_error_callback = NULL;
 139         mi->the_error_signal_userdata  = NULL;
 140         /* connection is locked because where not connected */
 141         mi->connection_lock = TRUE;
 142
 143         /* set queue to NULL */
 144         mi->queue = NULL;
 145         /* search stuff */
 146         mi->search_type = MPD_SEARCH_TYPE_NONE;
 147         /* no need to initialize, but set it to anything anyway*/
 148         mi->search_field = MPD_TAG_ITEM_ARTIST;
 149
 150     /* outputs */
 151     mi->num_outputs = 0;
 152     mi->output_states = NULL;
 153     /* set 0 */
 154     memset((mi->supported_tags), 0,sizeof(mi->supported_tags));
 155
 156     mi->has_idle = 0;
 157         /* commands */
 158         mi->commands = NULL;
 159         return mi;
 160 }
 161
 162 void mpd_free(MpdObj *mi)
 163 {
 164         debug_printf(DEBUG_INFO, "destroying MpdObj object\n");
 165         if(mi->connected)
 166         {
 167                 /* disconnect */
 168                 debug_printf(DEBUG_WARNING, "Connection still running, disconnecting\n");
 169                 mpd_disconnect(mi);
 170         }
 171         if(mi->hostname)
 172         {
 173                 free(mi->hostname);
 174         }
 175         if(mi->password)
 176         {
 177                 free(mi->password);
 178         }
 179         if(mi->error_msg)
 180         {
 181                 free(mi->error_msg);
 182         }
 183         if(mi->connection)
 184         {
 185                 /* obsolete */
 186                 mpd_closeConnection(mi->connection);
 187         }
 188         if(mi->status)
 189         {
 190                 mpd_freeStatus(mi->status);
 191         }
 192         if(mi->stats)
 193         {
 194                 mpd_freeStats(mi->stats);
 195         }
 196         if(mi->CurrentSong)
 197         {
 198                 mpd_freeSong(mi->CurrentSong);
 199         }
 200         mpd_free_queue_ob(mi);
 201         mpd_server_free_commands(mi);
 202         free(mi);
 203 }
 204
 205 int mpd_check_error(MpdObj *mi)
 206 {
 207         if(mi == NULL)
 208         {
 209                 debug_printf(DEBUG_ERROR, "mi == NULL?");
 210                 return MPD_ARGS_ERROR;
 211         }
 212
 213         /* this shouldn't happen, ever */
 214         if(mi->connection == NULL)
 215         {
 216                 debug_printf(DEBUG_ERROR, "mi->connection == NULL?");
 217                 return MPD_FATAL_ERROR;
 218         }
 219
 220         /* TODO: map these errors in the future */
 221         mi->error = mi->connection->error;
 222         mi->error_mpd_code = mi->connection->errorCode;
 223         /*TODO: do I need to strdup this? */
 224     if(!g_utf8_validate(mi->connection->errorStr, -1, NULL)){
 225         mi->error_msg = g_locale_to_utf8(mi->connection->errorStr, -1, NULL, NULL,NULL);
 226     }else{
 227         mi->error_msg = g_strdup(mi->connection->errorStr);
 228     }
 229
 230     if(mi->error_msg == NULL) mi->error_msg = g_strdup("Failed to convert error message to utf-8");
 231
 232         /* Check for permission */
 233         /* First check for an error reported by MPD
 234          * Then check what type of error mpd reported
 235          */
 236         if(mi->error == MPD_ERROR_ACK)
 237         {
 238
 239                 debug_printf(DEBUG_ERROR,"clearing errors in mpd_Connection: %i-%s", mi->connection->errorCode, mi->connection->errorStr);
 240                 mpd_clearError(mi->connection);
 241                 if (mi->the_error_callback)
 242                 {
 243             debug_printf(DEBUG_ERROR, "Error callback 1 (ACK)");
 244                         if(mi->the_error_callback(mi, mi->error_mpd_code, mi->error_msg, mi->the_error_signal_userdata ))
 245             {
 246                 debug_printf(DEBUG_ERROR, "Error callback told me to disconnect");
 247                 mpd_disconnect(mi);
 248                 free(mi->error_msg);
 249                 mi->error_msg = NULL;
 250
 251                 return MPD_SERVER_ERROR;
 252             }
 253                 }
 254                 free(mi->error_msg);
 255                 mi->error_msg = NULL;
 256                 return TRUE;
 257         }
 258         if(mi->error)
 259         {
 260
 261                 debug_printf(DEBUG_ERROR, "Following error occurred: %i: code: %i msg: %s", mi->error,mi->connection->errorCode, mi->error_msg);
 262
 263                 if (mi->the_error_callback)
 264                 {
 265             debug_printf(DEBUG_ERROR, "Error callback 2");
 266                         mi->the_error_callback(mi, mi->error, mi->error_msg, mi->the_error_signal_userdata );
 267                 }
 268                 mpd_disconnect(mi);
 269                 free(mi->error_msg);
 270                 mi->error_msg = NULL;
 271
 272                 return MPD_SERVER_ERROR;
 273         }
 274         free(mi->error_msg);
 275         mi->error_msg = NULL;
 276         return MPD_OK;
 277 }
 278
 279
 280
 281 int mpd_lock_conn(MpdObj *mi)
 282 {
 283
 284         if(mi->connection_lock)
 285         {
 286                 debug_printf(DEBUG_WARNING, "Failed to lock connection, already locked\n");
 287                 return MPD_LOCK_FAILED;
 288         }
 289         mi->connection_lock = TRUE;
 290         return MPD_OK;
 291 }
 292
 293 int mpd_unlock_conn(MpdObj *mi)
 294 {
 295         if(!mi->connection_lock)
 296         {
 297                 debug_printf(DEBUG_ERROR, "Failed to unlock connection, already unlocked\n");
 298                 return MPD_LOCK_FAILED;
 299         }
 300
 301         mi->connection_lock = FALSE;
 302
 303         return mpd_check_error(mi);
 304 }
 305
 306 MpdObj * mpd_new_default()
 307 {
 308         debug_printf(DEBUG_INFO, "creating a new mpdInt object\n");
 309         return mpd_create();
 310 }
 311
 312 MpdObj *mpd_new(char *hostname,  int port, char *password)
 313 {
 314         MpdObj *mi = mpd_create();
 315         if(mi == NULL)
 316         {
 317                 return NULL;
 318         }
 319         if(hostname != NULL)
 320         {
 321                 mpd_set_hostname(mi, hostname);
 322         }
 323         if(port != 0)
 324         {
 325                 mpd_set_port(mi, port);
 326         }
 327         if(password != NULL)
 328         {
 329                 mpd_set_password(mi, password);
 330         }
 331         return mi;
 332 }
 333
 334
 335 const char * mpd_get_hostname(MpdObj *mi)
 336 {
 337         if(mi == NULL)
 338         {
 339                 return NULL;
 340         }
 341         return mi->hostname;
 342 }
 343
 344 int mpd_set_hostname(MpdObj *mi, char *hostname)
 345 {
 346         if(mi == NULL)
 347         {
 348                 debug_printf(DEBUG_ERROR, "mi == NULL\n");
 349                 return MPD_ARGS_ERROR;
 350         }
 351
 352         if(mi->hostname != NULL)
 353         {
 354                 free(mi->hostname);
 355         }
 356         /* possible location todo some post processing of hostname */
 357         mi->hostname = strdup(hostname);
 358         return MPD_OK;
 359 }
 360
 361 int mpd_set_password(MpdObj *mi, const char *password)
 362 {
 363         if(mi == NULL)
 364         {
 365                 debug_printf(DEBUG_ERROR, "mi == NULL\n");
 366                 return MPD_ARGS_ERROR;
 367         }
 368
 369         if(mi->password != NULL)
 370         {
 371                 free(mi->password);
 372         }
 373         /* possible location todo some post processing of password */
 374         mi->password = strdup(password);
 375         return MPD_OK;
 376 }
 377
 378
 379 int mpd_send_password(MpdObj *mi)
 380 {
 381         if(!mi) return MPD_ARGS_ERROR;
 382         if(mi->password && mpd_check_connected(mi) && strlen(mi->password))
 383         {
 384                 if(mpd_lock_conn(mi))
 385                 {
 386                         debug_printf(DEBUG_WARNING, "failed to lock connection");
 387                         return MPD_LOCK_FAILED;
 388                 }
 389                 mpd_sendPasswordCommand(mi->connection, mi->password);
 390                 mpd_finishCommand(mi->connection);
 391                 if(mpd_unlock_conn(mi))
 392                 {
 393                         debug_printf(DEBUG_ERROR, "Failed to unlock connection\n");
 394                         return MPD_LOCK_FAILED;
 395                 }
 396                 mpd_server_get_allowed_commands(mi);
 397                 /*TODO: should I do it here, or in the
 398                  * mpd_server_get_allowed_command, so it also get's executed on
 399                  * connect
 400                  */
 401                 if((mi->the_status_changed_callback != NULL))
 402                 {
 403                         mi->the_status_changed_callback( mi,
 404                                         MPD_CST_PERMISSION, mi->the_status_changed_signal_userdata );
 405                 }
 406         }
 407         return MPD_OK;
 408 }
 409
 410 int mpd_set_port(MpdObj *mi, int port)
 411 {
 412         if(mi == NULL)
 413         {
 414                 debug_printf(DEBUG_ERROR, "mi == NULL\n");
 415                 return MPD_ARGS_ERROR;
 416         }
 417         mi->port = port;
 418         return MPD_OK;
 419 }
 420
 421 int mpd_set_connection_timeout(MpdObj *mi, float timeout)
 422 {
 423         if(mi == NULL)
 424         {
 425                 debug_printf(DEBUG_ERROR, "mi == NULL\n");
 426                 return MPD_ARGS_ERROR;
 427         }
 428         mi->connection_timeout = timeout;
 429         if(mpd_check_connected(mi))
 430         {
 431                 /*TODO: set timeout */
 432                 if(mpd_lock_conn(mi))
 433                 {
 434                         debug_printf(DEBUG_ERROR,"lock failed\n");
 435                         return MPD_LOCK_FAILED;
 436                 }
 437                 mpd_setConnectionTimeout(mi->connection, timeout);
 438                 mpd_finishCommand(mi->connection);
 439
 440                 mpd_unlock_conn(mi);
 441
 442         }
 443         return MPD_OK;
 444 }
 445
 446 static void mpd_server_free_commands(MpdObj *mi)
 447 {
 448         if(mi->commands)
 449         {
 450                 int i=0;
 451                 while(mi->commands[i].command_name)
 452                 {
 453                         free(mi->commands[i].command_name);
 454                         i++;
 455                 }
 456                 free(mi->commands);
 457                 mi->commands = NULL;
 458         }
 459 }
 460
 461 char *mpd_server_get_version(MpdObj *mi)
 462 {
 463         char *retval = NULL;
 464         if(!mi || !mpd_check_connected(mi))
 465                 return NULL;
 466         retval = malloc(10*sizeof(char));
 467         snprintf(retval,10,"%i.%i.%i", mi->connection->version[0], mi->connection->version[1], mi->connection->version[2]);
 468         /* always make sure the string is terminated */
 469         retval[9] = '\0';
 470         return retval;
 471 }
 472
 473 int mpd_server_get_allowed_commands(MpdObj *mi)
 474 {
 475         char *temp = NULL;
 476         int num_commands = 0;
 477         if(!mi){
 478                 debug_printf(DEBUG_ERROR, "mi != NULL failed\n");
 479                 return MPD_ARGS_ERROR;
 480         }
 481         if(!mpd_check_connected(mi)) {
 482                 debug_printf(DEBUG_WARNING, "Not Connected");
 483                 return MPD_NOT_CONNECTED;
 484         }
 485         if(!mpd_server_check_version(mi,0,12,0)){
 486                 debug_printf(DEBUG_INFO, "Not supported by mpd");
 487                 return MPD_SERVER_NOT_SUPPORTED;
 488         }
 489
 490         mpd_server_free_commands(mi);
 491
 492         if(mpd_lock_conn(mi))
 493         {
 494                 debug_printf(DEBUG_ERROR, "lock failed");
 495                 return MPD_LOCK_FAILED;
 496         }
 497         mpd_sendCommandsCommand(mi->connection);
 498         while((temp = mpd_getNextCommand(mi->connection)))
 499         {
 500                 num_commands++;
 501                 mi->commands = realloc(mi->commands, (num_commands+1)*sizeof(MpdCommand));
 502                 mi->commands[num_commands-1].command_name = temp;
 503                 mi->commands[num_commands-1].enabled = TRUE;
 504                 mi->commands[num_commands].command_name = NULL;
 505                 mi->commands[num_commands].enabled = FALSE;
 506         if(strcmp(mi->commands[num_commands-1].command_name, "idle") == 0) {
 507             mi->has_idle = TRUE;
 508         }
 509         }
 510         mpd_finishCommand(mi->connection);
 511         mpd_sendNotCommandsCommand(mi->connection);
 512         while((temp = mpd_getNextCommand(mi->connection)))
 513         {
 514                 num_commands++;
 515                 mi->commands = realloc(mi->commands, (num_commands+1)*sizeof(MpdCommand));
 516                 mi->commands[num_commands-1].command_name = temp;
 517                 mi->commands[num_commands-1].enabled = FALSE;
 518                 mi->commands[num_commands].command_name = NULL;
 519                 mi->commands[num_commands].enabled = FALSE;
 520         }
 521         mpd_finishCommand(mi->connection);
 522
 523         if(mpd_unlock_conn(mi))
 524     {
 525         return MPD_LOCK_FAILED;
 526     }
 527         return MPD_OK;
 528 }
 529
 530
 531
 532 int mpd_disconnect(MpdObj *mi)
 533 {
 534
 535         /* lock */
 536         mpd_lock_conn(mi);
 537         debug_printf(DEBUG_INFO, "disconnecting\n");
 538
 539         if(mi->connection)
 540         {
 541                 mpd_closeConnection(mi->connection);
 542                 mi->connection = NULL;
 543         }
 544         if(mi->status)
 545         {
 546                 mpd_freeStatus(mi->status);
 547                 mi->status = NULL;
 548         }
 549         if(mi->stats)
 550         {
 551                 mpd_freeStats(mi->stats);
 552                 mi->stats = NULL;
 553         }
 554         if(mi->CurrentSong)
 555         {
 556                 mpd_freeSong(mi->CurrentSong);
 557                 mi->CurrentSong = NULL;
 558         }
 559         mi->CurrentState.playlistid = -1;
 560         mi->CurrentState.storedplaylistid = -1;
 561         mi->CurrentState.state = -1;
 562         mi->CurrentState.songid = -1;
 563         mi->CurrentState.songpos = -1;
 564         mi->CurrentState.dbUpdateTime = 0;
 565         mi->CurrentState.updatingDb = 0;
 566         mi->CurrentState.repeat = -1;
 567         mi->CurrentState.random = -1;
 568         mi->CurrentState.volume = -2;
 569         mi->CurrentState.xfade  = -1;
 570         mi->CurrentState.totaltime = 0;
 571         mi->CurrentState.elapsedtime = 0;
 572         mi->CurrentState.bitrate = 0;
 573         mi->CurrentState.samplerate = 0;
 574         mi->CurrentState.channels = 0;
 575         mi->CurrentState.bits = 0;
 576     mi->CurrentState.playlistLength = 0;
 577     mi->CurrentState.error[0] = '\0';
 578         /* search stuff */
 579         mi->search_type = MPD_SEARCH_TYPE_NONE;
 580         /* no need to initialize, but set it to anything anyway*/
 581         mi->search_field = MPD_TAG_ITEM_ARTIST;
 582     /* outputs */
 583     mi->num_outputs = 0;
 584     if(mi->output_states)
 585         g_free(mi->output_states);
 586     mi->output_states = NULL;
 587
 588     /* set 0 */
 589     memset((mi->supported_tags), 0,sizeof(mi->supported_tags));
 590
 591     mi->has_idle = 0;
 592
 593         memcpy(&(mi->OldState), &(mi->CurrentState) , sizeof(MpdServerState));
 594
 595         mpd_free_queue_ob(mi);
 596         mpd_server_free_commands(mi);
 597         /*don't reset errors */
 598         /* Remove this signal, we don't actually disconnect */
 599         if(mi->connected)
 600         {
 601                 /* set disconnect flag */
 602                 mi->connected = FALSE;
 603
 604                 if(mi->the_connection_changed_callback != NULL)
 605                 {
 606                         mi->the_connection_changed_callback( mi, FALSE, mi->the_connection_changed_signal_userdata );
 607                 }
 608         }
 609         debug_printf(DEBUG_INFO, "Disconnect completed\n");
 610         return MPD_OK;
 611 }
 612 int mpd_connect(MpdObj *mi)
 613 {
 614         return mpd_connect_real(mi,NULL);
 615 }
 616 int mpd_connect_real(MpdObj *mi,mpd_Connection *connection)
 617 {
 618     int retv;
 619     if(mi == NULL)
 620         {
 621                 /* should return some spiffy error here */
 622                 debug_printf(DEBUG_ERROR, "mi != NULL failed");
 623                 return MPD_ARGS_ERROR;
 624         }
 625         /* reset errors */
 626         mi->error = 0;
 627         mi->error_mpd_code = 0;
 628         if(mi->error_msg != NULL)
 629         {
 630                 free(mi->error_msg);
 631         }
 632         mi->error_msg = NULL;
 633
 634         debug_printf(DEBUG_INFO, "connecting\n");
 635         mpd_init_MpdServerState(&(mi->CurrentState));
 636
 637         memcpy(&(mi->OldState), &(mi->CurrentState), sizeof(MpdServerState));
 638
 639         if(mi->connected)
 640         {
 641                 /* disconnect */
 642                 mpd_disconnect(mi);
 643         }
 644
 645         if(mi->hostname == NULL)
 646         {
 647                 mpd_set_hostname(mi, "localhost");
 648         }
 649         /* make sure this is locked */
 650         if(!mi->connection_lock)
 651         {
 652                 mpd_lock_conn(mi);
 653         }
 654         if(connection) {
 655                 mi->connection = connection;
 656         } else {
 657                 /* make timeout configurable */
 658                 mi->connection = mpd_newConnection(mi->hostname,mi->port,mi->connection_timeout);
 659         }
 660         if(mi->connection == NULL)
 661         {
 662                 /* TODO: make seperate error message? */
 663                 return MPD_NOT_CONNECTED;
 664         }
 665         if(mpd_check_error(mi) != MPD_OK)
 666         {
 667                 /* TODO: make seperate error message? */
 668                 return MPD_NOT_CONNECTED;
 669         }
 670
 671         /* set connected state */
 672         mi->connected = TRUE;
 673         if(mpd_unlock_conn(mi))
 674         {
 675                 return MPD_LOCK_FAILED;
 676         }
 677
 678         /* get the commands we are allowed to use */
 679         retv = mpd_server_get_allowed_commands(mi);
 680     if(retv!= MPD_OK)
 681     {
 682         return retv;
 683     }
 684 /*
 685
 686     retv = mpd_server_update_outputs(mi);
 687     if(retv != MPD_OK)
 688         return retv;
 689 */
 690     debug_printf(DEBUG_INFO,  "Propagating connection changed");
 691
 692     if(mi->the_connection_changed_callback != NULL)
 693         {
 694                 mi->the_connection_changed_callback( mi, TRUE, mi->the_connection_changed_signal_userdata );
 695         }
 696     retv = mpd_server_update_outputs(mi);
 697     /** update the supported tags */
 698     {
 699         int i;
 700         char **retv = mpd_server_get_tag_types(mi);
 701         if(retv){
 702             for(i=0;i<MPD_TAG_ITEM_ANY;i++)
 703             {
 704                 int j=0;
 705                 for(j=0;retv[j] && strcasecmp(retv[j],mpdTagItemKeys[i]); j++);
 706                 if(retv[j]) mi->supported_tags[i] = TRUE;
 707                 else mi->supported_tags[i] = FALSE;
 708             }
 709             g_strfreev(retv);
 710         }
 711         /* also always true */
 712         mi->supported_tags[MPD_TAG_ITEM_FILENAME] = TRUE;
 713         mi->supported_tags[MPD_TAG_ITEM_ANY] = TRUE;
 714         printf("Supported tags by server\n");
 715         for(i=0;i< MPD_TAG_NUM_OF_ITEM_TYPES;i++){
 716             printf("%20s: %s\n", mpdTagItemKeys[i], (mi->supported_tags[i])?"true":"false");
 717         }
 718     }
 719     /*
 720     if(retv != MPD_OK)
 721         return retv;
 722         */
 723         debug_printf(DEBUG_INFO, "Connected to mpd");
 724         return MPD_OK;
 725 }
 726
 727 int mpd_check_connected(MpdObj *mi)
 728 {
 729         if(mi == NULL)
 730         {
 731                 return FALSE;
 732         }
 733         return mi->connected;
 734 }
 735
 736
 737 /* SIGNALS */
 738 void    mpd_signal_connect_status_changed        (MpdObj *mi, StatusChangedCallback status_changed, void *userdata)
 739 {
 740         if(mi == NULL)
 741         {
 742                 debug_printf(DEBUG_ERROR, "mi != NULL failed");
 743                 return;
 744         }
 745         mi->the_status_changed_callback = status_changed;
 746         mi->the_status_changed_signal_userdata = userdata;
 747 }
 748
 749
 750 void    mpd_signal_connect_error(MpdObj *mi, ErrorCallback error_callback, void *userdata)
 751 {
 752         if(mi == NULL)
 753         {
 754                 debug_printf(DEBUG_ERROR, "mi != NULL failed");
 755                 return;
 756         }
 757         mi->the_error_callback = error_callback;
 758         mi->the_error_signal_userdata = userdata;
 759 }
 760
 761 void    mpd_signal_connect_connection_changed(MpdObj *mi, ConnectionChangedCallback connection_changed, void *userdata)
 762 {
 763         if(mi == NULL)
 764         {
 765                 debug_printf(DEBUG_ERROR, "mi != NULL failed");
 766                 return;
 767         }
 768         mi->the_connection_changed_callback = connection_changed;
 769         mi->the_connection_changed_signal_userdata = userdata;
 770 }
 771
 772
 773 /* more playlist */
 774 /* MpdData Part */
 775 MpdData *mpd_new_data_struct(void)
 776 {
 777         MpdData_real* data;
 778     data = g_slice_new(MpdData_real);
 779         data->type = 0;
 780
 781         data->tag_type = 0;
 782         data->tag = NULL;
 783         data->song = NULL;
 784         data->directory = NULL;
 785         data->playlist = NULL;
 786         data->output_dev = NULL;
 787         data->next = NULL;
 788         data->prev = NULL;
 789     data->first = NULL;
 790
 791     data->userdata = NULL;
 792     data->freefunc = NULL;
 793         return (MpdData*)data;
 794 }
 795
 796 MpdData *mpd_new_data_struct_append(MpdData  * data)
 797 {
 798         MpdData_real *data_real = (MpdData_real*)data;
 799         if(data_real == NULL)
 800         {
 801                 data_real = (MpdData_real*)mpd_new_data_struct();
 802         data_real->first = data_real;
 803         }
 804         else
 805         {
 806                 data_real->next = (MpdData_real*)mpd_new_data_struct();
 807                 data_real->next->prev = data_real;
 808                 data_real = data_real->next;
 809                 data_real->next = NULL;
 810         data_real->first = data_real->prev->first;
 811         }
 812         return (MpdData*)data_real;
 813 }
 814
 815 MpdData * mpd_data_get_first(MpdData const * const data)
 816 {
 817         MpdData_real const * const data_real = (MpdData_real const * const)data;
 818         if(data_real != NULL)
 819         {
 820         return (MpdData*)data_real->first;
 821     }
 822         return NULL;
 823 }
 824
 825
 826 MpdData * mpd_data_get_next(MpdData * const data)
 827 {
 828         return mpd_data_get_next_real(data, TRUE);
 829 }
 830
 831 MpdData * mpd_data_get_next_real(MpdData * const data, int kill_list)
 832 {
 833         MpdData_real *data_real = (MpdData_real*)data;
 834         if (data_real != NULL)
 835         {
 836                 if (data_real->next != NULL )
 837                 {
 838                         return (MpdData*)data_real->next;
 839                 }
 840                 else
 841                 {
 842                         if (kill_list) mpd_data_free((MpdData*)data_real);
 843                         return NULL;
 844                 }
 845         }
 846         return (MpdData*)data_real;
 847 }
 848
 849 int mpd_data_is_last(MpdData const * const data)
 850 {
 851         MpdData_real const * const data_real = (MpdData_real const * const)data;
 852         if(data_real != NULL)
 853         {
 854                 if (data_real->next == NULL)
 855                 {
 856                         return TRUE;
 857                 }
 858         }
 859         return FALSE;
 860 }
 861 /*
 862 MpdData_head *mpd_data_get_head(MpdData const * const data) {
 863         return ((MpdData_real*)data)->head;
 864 }
 865 */
 866 MpdData* mpd_data_concatenate( MpdData  * const first, MpdData  * const second)
 867 {
 868         MpdData_real *first_real  = (MpdData_real*)first;
 869         MpdData_real *second_real = (MpdData_real*)second;
 870         MpdData_real *first_head  = NULL;
 871
 872         if ( first == NULL ) {
 873                 if ( second != NULL )
 874                         return (MpdData*)second_real;
 875                 else
 876                         return NULL;
 877         } else {
 878                 if ( second == NULL )
 879                         return (MpdData*)first_real;
 880         }
 881
 882         first_head = (MpdData_real *)mpd_data_get_first(first);
 883
 884         /* find last element in first data list */
 885         while (!mpd_data_is_last((MpdData*)first_real)) first_real = (MpdData_real*)mpd_data_get_next_real((MpdData*)first_real, FALSE);
 886         second_real =(MpdData_real*) mpd_data_get_first((MpdData*)second_real);
 887
 888         first_real->next = second_real;
 889         second_real->prev = first_real;
 890
 891         /* I need to set all the -> first correct */
 892         while (second_real)
 893         {
 894                 second_real->first = first_head;
 895                 second_real = (MpdData_real*)mpd_data_get_next_real((MpdData*)second_real, FALSE);
 896         }
 897
 898         return (MpdData*)first_head;
 899 }
 900 /**
 901  * Deletes an item from the list. It returns the next item in the list.
 902  * if that is not available, it will return the last item
 903  */
 904 MpdData * mpd_data_delete_item(MpdData *data)
 905 {
 906     MpdData_real *temp = NULL, *data_real = (MpdData_real*)data;
 907     if(data_real == NULL) return NULL;
 908     /* if there is a next item, fix the prev pointer of the next item */
 909     if (data_real->next)
 910     {
 911         data_real->next->prev = data_real->prev;
 912         temp = data_real->next;
 913     }
 914     /* if there is a previous item, fix the next pointer of the previous item */
 915     if (data_real->prev)
 916     {
 917         /* the next item of the previous is the next item of the current */
 918         data_real->prev->next = data_real->next;
 919         /* temp is the previous item */
 920         temp = data_real->prev;
 921     }
 922
 923     /* fix first,  if removed item is the first */
 924     if(temp && temp->first == data_real)
 925     {
 926         MpdData_real *first,*node = temp;
 927         /* get first */
 928         for(;node->prev;node = node->prev);
 929         first = node;
 930         while(node){
 931             node->first = first;
 932             node = node->next;
 933         }
 934     }
 935     /* make the removed row a valid list, so I can use the default free function to free it */
 936     data_real->next = NULL;
 937     data_real->prev = NULL;
 938     data_real->first = data_real;
 939     /* free it */
 940     mpd_data_free((MpdData *)data_real);
 941
 942     return (MpdData *)temp;
 943 }
 944
 945 void mpd_data_free(MpdData *data)
 946 {
 947     MpdData_real *data_real,*temp;
 948     if(data == NULL)
 949     {
 950         debug_printf(DEBUG_ERROR, "data != NULL Failed");
 951         return;
 952     }
 953     data_real = (MpdData_real *)mpd_data_get_first(data);
 954     while(data_real){
 955         temp = data_real;
 956         if (data_real->type == MPD_DATA_TYPE_SONG) {
 957             if(data_real->song) mpd_freeSong(data_real->song);
 958         } else if (data_real->type == MPD_DATA_TYPE_OUTPUT_DEV) {
 959             mpd_freeOutputElement(data_real->output_dev);
 960         } else if(data_real->type == MPD_DATA_TYPE_DIRECTORY) {
 961             if(data_real->directory)free(data_real->directory);
 962         } else if(data_real->type == MPD_DATA_TYPE_PLAYLIST) {
 963             if(data_real->playlist) mpd_freePlaylistFile(data_real->playlist);
 964         } else {
 965             free((void*)(data_real->tag));
 966         }
 967         if(data_real->freefunc)
 968         {
 969             if(data_real->userdata)
 970                 data_real->freefunc(data_real->userdata);
 971         }
 972         data_real = data_real->next;
 973         g_slice_free1(sizeof(*temp), temp);
 974     }
 975 }
 976
 977 /* clean this up.. make one while loop */
 978 static void mpd_free_queue_ob(MpdObj *mi)
 979 {
 980     MpdQueue *temp = NULL;
 981     if(mi == NULL)
 982     {
 983         debug_printf(DEBUG_ERROR, "mi != NULL failed");
 984         return;
 985     }
 986     if(mi->queue == NULL)
 987     {
 988         debug_printf(DEBUG_INFO, "mi->queue != NULL failed, nothing to clean.");
 989         return;
 990     }
 991     mi->queue = mi->queue->first;
 992     while(mi->queue != NULL)
 993     {
 994         temp = mi->queue->next;
 995
 996         if(mi->queue->path != NULL)
 997         {
 998             free(mi->queue->path);
 999         }
1000
1001         free(mi->queue);
1002         mi->queue = temp;
1003     }
1004     mi->queue = NULL;
1005
1006 }
1007
1008 MpdQueue *mpd_new_queue_struct()
1009 {
1010     MpdQueue* queue = malloc(sizeof(MpdQueue));
1011
1012     queue->type = 0;
1013     queue->path = NULL;
1014     queue->id = 0;
1015
1016     return queue;
1017 }
1018
1019
1020 void mpd_queue_get_next(MpdObj *mi)
1021 {
1022     if(mi->queue != NULL && mi->queue->next != NULL)
1023     {
1024         mi->queue = mi->queue->next;
1025     }
1026     else if(mi->queue->next == NULL)
1027     {
1028         mpd_free_queue_ob(mi);
1029         mi->queue = NULL;
1030     }
1031 }
1032
1033 long unsigned mpd_server_get_database_update_time(MpdObj *mi)
1034 {
1035     if(!mpd_check_connected(mi))
1036     {
1037         debug_printf(DEBUG_WARNING,"not connected\n");
1038         return MPD_NOT_CONNECTED;
1039     }
1040     if(mpd_stats_check(mi) != MPD_OK)
1041     {
1042         debug_printf(DEBUG_WARNING,"Failed grabbing status\n");
1043         return MPD_STATS_FAILED;
1044     }
1045     return mi->stats->dbUpdateTime;
1046 }
1047
1048
1049 MpdData * mpd_server_get_output_devices(MpdObj *mi)
1050 {
1051     mpd_OutputEntity *output = NULL;
1052     MpdData *data = NULL;
1053     if(!mpd_check_connected(mi))
1054     {
1055         debug_printf(DEBUG_WARNING,"not connected\n");
1056         return NULL;
1057     }
1058     /* TODO: Check version */
1059     if(mpd_lock_conn(mi))
1060     {
1061         debug_printf(DEBUG_ERROR,"lock failed\n");
1062         return NULL;
1063     }
1064
1065     mpd_sendOutputsCommand(mi->connection);
1066     while (( output = mpd_getNextOutput(mi->connection)) != NULL)
1067     {
1068         data = mpd_new_data_struct_append(data);
1069         data->type = MPD_DATA_TYPE_OUTPUT_DEV;
1070         data->output_dev = output;
1071     }
1072     mpd_finishCommand(mi->connection);
1073
1074     /* unlock */
1075     mpd_unlock_conn(mi);
1076     if(data == NULL)
1077     {
1078         return NULL;
1079     }
1080     return mpd_data_get_first(data);
1081 }
1082
1083 int mpd_server_set_output_device(MpdObj *mi,int device_id,int state)
1084 {
1085     if(!mpd_check_connected(mi))
1086     {
1087         debug_printf(DEBUG_WARNING,"not connected\n");
1088         return MPD_NOT_CONNECTED;
1089     }
1090     if(mpd_lock_conn(mi))
1091     {
1092         debug_printf(DEBUG_ERROR,"lock failed\n");
1093         return MPD_LOCK_FAILED;
1094     }
1095     if(state)
1096     {
1097         mpd_sendEnableOutputCommand(mi->connection, device_id);
1098     }
1099     else
1100     {
1101         mpd_sendDisableOutputCommand(mi->connection, device_id);
1102     }
1103     mpd_finishCommand(mi->connection);
1104
1105     mpd_unlock_conn(mi);
1106     mpd_status_queue_update(mi);
1107     return FALSE;
1108 }
1109
1110 int mpd_server_check_version(MpdObj *mi, int major, int minor, int micro)
1111 {
1112     if(!mpd_check_connected(mi))
1113     {
1114         debug_printf(DEBUG_WARNING,"not connected\n");
1115         return FALSE;
1116     }
1117     if(major > mi->connection->version[0]) return FALSE;
1118     if(mi->connection->version[0] > major) return TRUE;
1119     if(minor > mi->connection->version[1]) return FALSE;
1120     if(mi->connection->version[1] > minor) return TRUE;
1121     if(micro > mi->connection->version[2]) return FALSE;
1122     if(mi->connection->version[2] > micro) return TRUE;
1123     return TRUE;
1124 }
1125
1126 int mpd_server_check_command_allowed(MpdObj *mi, const char *command)
1127 {
1128     int i;
1129     if(!mi || !command) return MPD_SERVER_COMMAND_ERROR;
1130     /* when we are connected to a mpd server that doesn't support commands and not commands
1131      * feature. (like mpd 0.11.5) allow everything
1132      */
1133     if(!mpd_server_check_version(mi, 0,12,0)) return MPD_SERVER_COMMAND_ALLOWED;
1134     /*
1135      * Also when somehow we failted to get commands
1136      */
1137     if(mi->commands == NULL) return MPD_SERVER_COMMAND_ALLOWED;
1138
1139
1140
1141     for(i=0;mi->commands[i].command_name;i++)
1142     {
1143         if(!strcasecmp(mi->commands[i].command_name, command))
1144             return mi->commands[i].enabled;
1145     }
1146     return MPD_SERVER_COMMAND_NOT_SUPPORTED;
1147 }
1148
1149 char ** mpd_server_get_url_handlers(MpdObj *mi)
1150 {
1151     char *temp = NULL;
1152     int i=0;
1153     char **retv = NULL;
1154     if(!mpd_check_connected(mi))
1155     {
1156         debug_printf(DEBUG_WARNING,"not connected\n");
1157         return FALSE;
1158     }
1159     if(mpd_lock_conn(mi))
1160     {
1161         debug_printf(DEBUG_ERROR,"lock failed\n");
1162         return NULL;
1163     }
1164     mpd_sendUrlHandlersCommand(mi->connection);
1165     while((temp = mpd_getNextHandler(mi->connection)) != NULL)
1166     {
1167         retv = realloc(retv,(i+2)*sizeof(*retv));
1168         retv[i]   = temp;
1169         retv[i+1] = NULL;
1170         i++;
1171     }
1172     mpd_finishCommand(mi->connection);
1173
1174
1175     mpd_unlock_conn(mi);
1176     return retv;
1177 }
1178 char ** mpd_server_get_tag_types(MpdObj *mi)
1179 {
1180     char *temp = NULL;
1181     int i=0;
1182     char **retv = NULL;
1183     if(!mpd_check_connected(mi))
1184     {
1185         debug_printf(DEBUG_WARNING,"not connected\n");
1186         return FALSE;
1187     }
1188     if(mpd_lock_conn(mi))
1189     {
1190         debug_printf(DEBUG_ERROR,"lock failed\n");
1191         return NULL;
1192     }
1193     mpd_sendTagTypesCommand(mi->connection);
1194     while((temp = mpd_getNextTagType(mi->connection)) != NULL)
1195     {
1196         retv = realloc(retv,(i+2)*sizeof(*retv));
1197         retv[i]   = temp;
1198         retv[i+1] = NULL;
1199         i++;
1200     }
1201     mpd_finishCommand(mi->connection);
1202
1203
1204     mpd_unlock_conn(mi);
1205     return retv;
1206 }
1207
1208 int mpd_misc_get_tag_by_name(char *name)
1209 {
1210     int i;
1211     if(name == NULL)
1212     {
1213         return MPD_ARGS_ERROR;
1214     }
1215     for(i=0; i < MPD_TAG_NUM_OF_ITEM_TYPES; i++)
1216     {
1217         if(!strcasecmp(mpdTagItemKeys[i], name))
1218         {
1219             return i;
1220         }
1221     }
1222     return MPD_TAG_NOT_FOUND;
1223 }
1224
1225 int mpd_server_update_outputs(MpdObj *mi)
1226 {
1227     mpd_OutputEntity *output = NULL;
1228     if(!mpd_check_connected(mi))
1229     {
1230         debug_printf(DEBUG_WARNING,"not connected\n");
1231         return MPD_NOT_CONNECTED;
1232     }
1233     if(mpd_lock_conn(mi))
1234     {
1235         debug_printf(DEBUG_ERROR,"lock failed\n");
1236         return MPD_LOCK_FAILED;
1237     }
1238     mpd_sendOutputsCommand(mi->connection);
1239     while (( output = mpd_getNextOutput(mi->connection)) != NULL)
1240     {
1241         mi->num_outputs++;
1242         mi->output_states = g_realloc(mi->output_states,mi->num_outputs*sizeof(int));
1243         mi->output_states[mi->num_outputs-1] = FALSE;/*output->enabled;*/
1244         mpd_freeOutputElement(output);
1245     }
1246     mpd_finishCommand(mi->connection);
1247     return mpd_unlock_conn(mi);
1248 }
1249
1250 int mpd_server_has_idle(MpdObj *mi)
1251 {
1252     return mi->has_idle;
1253 }
1254
1255 int mpd_server_tag_supported(MpdObj *mi, int tag)
1256 {
1257     if(!mi) return FALSE;
1258     if(tag < 0 || tag >= MPD_TAG_NUM_OF_ITEM_TYPES) {
1259         return FALSE;
1260     }
1261     return mi->supported_tags[tag];
1262 }