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
 691     retv = mpd_server_update_outputs(mi);
 692     /** update the supported tags */
 693     {
 694         int i;
 695         char **retv = mpd_server_get_tag_types(mi);
 696         if(retv){
 697             for(i=0;i<MPD_TAG_ITEM_ANY;i++)
 698             {
 699                 int j=0;
 700                 for(j=0;retv[j] && strcasecmp(retv[j],mpdTagItemKeys[i]); j++);
 701                 if(retv[j]) mi->supported_tags[i] = TRUE;
 702                 else mi->supported_tags[i] = FALSE;
 703             }
 704             g_strfreev(retv);
 705         }
 706         /* also always true */
 707         mi->supported_tags[MPD_TAG_ITEM_FILENAME] = TRUE;
 708         mi->supported_tags[MPD_TAG_ITEM_ANY] = TRUE;
 709     }
 710     debug_printf(DEBUG_INFO,  "Propagating connection changed");
 711
 712     if(mi->the_connection_changed_callback != NULL)
 713         {
 714                 mi->the_connection_changed_callback( mi, TRUE, mi->the_connection_changed_signal_userdata );
 715         }
 716     /*
 717     if(retv != MPD_OK)
 718         return retv;
 719         */
 720         debug_printf(DEBUG_INFO, "Connected to mpd");
 721         return MPD_OK;
 722 }
 723
 724 int mpd_check_connected(MpdObj *mi)
 725 {
 726         if(mi == NULL)
 727         {
 728                 return FALSE;
 729         }
 730         return mi->connected;
 731 }
 732
 733
 734 /* SIGNALS */
 735 void    mpd_signal_connect_status_changed        (MpdObj *mi, StatusChangedCallback status_changed, void *userdata)
 736 {
 737         if(mi == NULL)
 738         {
 739                 debug_printf(DEBUG_ERROR, "mi != NULL failed");
 740                 return;
 741         }
 742         mi->the_status_changed_callback = status_changed;
 743         mi->the_status_changed_signal_userdata = userdata;
 744 }
 745
 746
 747 void    mpd_signal_connect_error(MpdObj *mi, ErrorCallback error_callback, void *userdata)
 748 {
 749         if(mi == NULL)
 750         {
 751                 debug_printf(DEBUG_ERROR, "mi != NULL failed");
 752                 return;
 753         }
 754         mi->the_error_callback = error_callback;
 755         mi->the_error_signal_userdata = userdata;
 756 }
 757
 758 void    mpd_signal_connect_connection_changed(MpdObj *mi, ConnectionChangedCallback connection_changed, void *userdata)
 759 {
 760         if(mi == NULL)
 761         {
 762                 debug_printf(DEBUG_ERROR, "mi != NULL failed");
 763                 return;
 764         }
 765         mi->the_connection_changed_callback = connection_changed;
 766         mi->the_connection_changed_signal_userdata = userdata;
 767 }
 768
 769
 770 /* more playlist */
 771 /* MpdData Part */
 772 MpdData *mpd_new_data_struct(void)
 773 {
 774         MpdData_real* data;
 775     data = g_slice_new(MpdData_real);
 776         data->type = 0;
 777
 778         data->tag_type = 0;
 779         data->tag = NULL;
 780         data->song = NULL;
 781         data->directory = NULL;
 782         data->playlist = NULL;
 783         data->output_dev = NULL;
 784         data->next = NULL;
 785         data->prev = NULL;
 786     data->first = NULL;
 787
 788     data->userdata = NULL;
 789     data->freefunc = NULL;
 790         return (MpdData*)data;
 791 }
 792
 793 MpdData *mpd_new_data_struct_append(MpdData  * data)
 794 {
 795         MpdData_real *data_real = (MpdData_real*)data;
 796         if(data_real == NULL)
 797         {
 798                 data_real = (MpdData_real*)mpd_new_data_struct();
 799         data_real->first = data_real;
 800         }
 801         else
 802         {
 803                 data_real->next = (MpdData_real*)mpd_new_data_struct();
 804                 data_real->next->prev = data_real;
 805                 data_real = data_real->next;
 806                 data_real->next = NULL;
 807         data_real->first = data_real->prev->first;
 808         }
 809         return (MpdData*)data_real;
 810 }
 811
 812 MpdData * mpd_data_get_first(MpdData const * const data)
 813 {
 814         MpdData_real const * const data_real = (MpdData_real const * const)data;
 815         if(data_real != NULL)
 816         {
 817         return (MpdData*)data_real->first;
 818     }
 819         return NULL;
 820 }
 821
 822
 823 MpdData * mpd_data_get_next(MpdData * const data)
 824 {
 825         return mpd_data_get_next_real(data, TRUE);
 826 }
 827
 828 MpdData * mpd_data_get_next_real(MpdData * const data, int kill_list)
 829 {
 830         MpdData_real *data_real = (MpdData_real*)data;
 831         if (data_real != NULL)
 832         {
 833                 if (data_real->next != NULL )
 834                 {
 835                         return (MpdData*)data_real->next;
 836                 }
 837                 else
 838                 {
 839                         if (kill_list) mpd_data_free((MpdData*)data_real);
 840                         return NULL;
 841                 }
 842         }
 843         return (MpdData*)data_real;
 844 }
 845
 846 int mpd_data_is_last(MpdData const * const data)
 847 {
 848         MpdData_real const * const data_real = (MpdData_real const * const)data;
 849         if(data_real != NULL)
 850         {
 851                 if (data_real->next == NULL)
 852                 {
 853                         return TRUE;
 854                 }
 855         }
 856         return FALSE;
 857 }
 858 /*
 859 MpdData_head *mpd_data_get_head(MpdData const * const data) {
 860         return ((MpdData_real*)data)->head;
 861 }
 862 */
 863 MpdData* mpd_data_concatenate( MpdData  * const first, MpdData  * const second)
 864 {
 865         MpdData_real *first_real  = (MpdData_real*)first;
 866         MpdData_real *second_real = (MpdData_real*)second;
 867         MpdData_real *first_head  = NULL;
 868
 869         if ( first == NULL ) {
 870                 if ( second != NULL )
 871                         return (MpdData*)second_real;
 872                 else
 873                         return NULL;
 874         } else {
 875                 if ( second == NULL )
 876                         return (MpdData*)first_real;
 877         }
 878
 879         first_head = (MpdData_real *)mpd_data_get_first(first);
 880
 881         /* find last element in first data list */
 882         while (!mpd_data_is_last((MpdData*)first_real)) first_real = (MpdData_real*)mpd_data_get_next_real((MpdData*)first_real, FALSE);
 883         second_real =(MpdData_real*) mpd_data_get_first((MpdData*)second_real);
 884
 885         first_real->next = second_real;
 886         second_real->prev = first_real;
 887
 888         /* I need to set all the -> first correct */
 889         while (second_real)
 890         {
 891                 second_real->first = first_head;
 892                 second_real = (MpdData_real*)mpd_data_get_next_real((MpdData*)second_real, FALSE);
 893         }
 894
 895         return (MpdData*)first_head;
 896 }
 897 /**
 898  * Deletes an item from the list. It returns the next item in the list.
 899  * if that is not available, it will return the last item
 900  */
 901 MpdData * mpd_data_delete_item(MpdData *data)
 902 {
 903     MpdData_real *temp = NULL, *data_real = (MpdData_real*)data;
 904     if(data_real == NULL) return NULL;
 905     /* if there is a next item, fix the prev pointer of the next item */
 906     if (data_real->next)
 907     {
 908         data_real->next->prev = data_real->prev;
 909         temp = data_real->next;
 910     }
 911     /* if there is a previous item, fix the next pointer of the previous item */
 912     if (data_real->prev)
 913     {
 914         /* the next item of the previous is the next item of the current */
 915         data_real->prev->next = data_real->next;
 916         /* temp is the previous item */
 917         temp = data_real->prev;
 918     }
 919
 920     /* fix first,  if removed item is the first */
 921     if(temp && temp->first == data_real)
 922     {
 923         MpdData_real *first,*node = temp;
 924         /* get first */
 925         for(;node->prev;node = node->prev);
 926         first = node;
 927         while(node){
 928             node->first = first;
 929             node = node->next;
 930         }
 931     }
 932     /* make the removed row a valid list, so I can use the default free function to free it */
 933     data_real->next = NULL;
 934     data_real->prev = NULL;
 935     data_real->first = data_real;
 936     /* free it */
 937     mpd_data_free((MpdData *)data_real);
 938
 939     return (MpdData *)temp;
 940 }
 941
 942 void mpd_data_free(MpdData *data)
 943 {
 944     MpdData_real *data_real,*temp;
 945     if(data == NULL)
 946     {
 947         debug_printf(DEBUG_ERROR, "data != NULL Failed");
 948         return;
 949     }
 950     data_real = (MpdData_real *)mpd_data_get_first(data);
 951     while(data_real){
 952         temp = data_real;
 953         if (data_real->type == MPD_DATA_TYPE_SONG) {
 954             if(data_real->song) mpd_freeSong(data_real->song);
 955         } else if (data_real->type == MPD_DATA_TYPE_OUTPUT_DEV) {
 956             mpd_freeOutputElement(data_real->output_dev);
 957         } else if(data_real->type == MPD_DATA_TYPE_DIRECTORY) {
 958             if(data_real->directory)free(data_real->directory);
 959         } else if(data_real->type == MPD_DATA_TYPE_PLAYLIST) {
 960             if(data_real->playlist) mpd_freePlaylistFile(data_real->playlist);
 961         } else {
 962             free((void*)(data_real->tag));
 963         }
 964         if(data_real->freefunc)
 965         {
 966             if(data_real->userdata)
 967                 data_real->freefunc(data_real->userdata);
 968         }
 969         data_real = data_real->next;
 970         g_slice_free1(sizeof(*temp), temp);
 971     }
 972 }
 973
 974 /* clean this up.. make one while loop */
 975 static void mpd_free_queue_ob(MpdObj *mi)
 976 {
 977     MpdQueue *temp = NULL;
 978     if(mi == NULL)
 979     {
 980         debug_printf(DEBUG_ERROR, "mi != NULL failed");
 981         return;
 982     }
 983     if(mi->queue == NULL)
 984     {
 985         debug_printf(DEBUG_INFO, "mi->queue != NULL failed, nothing to clean.");
 986         return;
 987     }
 988     mi->queue = mi->queue->first;
 989     while(mi->queue != NULL)
 990     {
 991         temp = mi->queue->next;
 992
 993         if(mi->queue->path != NULL)
 994         {
 995             free(mi->queue->path);
 996         }
 997
 998         free(mi->queue);
 999         mi->queue = temp;
1000     }
1001     mi->queue = NULL;
1002
1003 }
1004
1005 MpdQueue *mpd_new_queue_struct()
1006 {
1007     MpdQueue* queue = malloc(sizeof(MpdQueue));
1008
1009     queue->type = 0;
1010     queue->path = NULL;
1011     queue->id = 0;
1012
1013     return queue;
1014 }
1015
1016
1017 void mpd_queue_get_next(MpdObj *mi)
1018 {
1019     if(mi->queue != NULL && mi->queue->next != NULL)
1020     {
1021         mi->queue = mi->queue->next;
1022     }
1023     else if(mi->queue->next == NULL)
1024     {
1025         mpd_free_queue_ob(mi);
1026         mi->queue = NULL;
1027     }
1028 }
1029
1030 long unsigned mpd_server_get_database_update_time(MpdObj *mi)
1031 {
1032     if(!mpd_check_connected(mi))
1033     {
1034         debug_printf(DEBUG_WARNING,"not connected\n");
1035         return MPD_NOT_CONNECTED;
1036     }
1037     if(mpd_stats_check(mi) != MPD_OK)
1038     {
1039         debug_printf(DEBUG_WARNING,"Failed grabbing status\n");
1040         return MPD_STATS_FAILED;
1041     }
1042     return mi->stats->dbUpdateTime;
1043 }
1044
1045
1046 MpdData * mpd_server_get_output_devices(MpdObj *mi)
1047 {
1048     mpd_OutputEntity *output = NULL;
1049     MpdData *data = NULL;
1050     if(!mpd_check_connected(mi))
1051     {
1052         debug_printf(DEBUG_WARNING,"not connected\n");
1053         return NULL;
1054     }
1055     /* TODO: Check version */
1056     if(mpd_lock_conn(mi))
1057     {
1058         debug_printf(DEBUG_ERROR,"lock failed\n");
1059         return NULL;
1060     }
1061
1062     mpd_sendOutputsCommand(mi->connection);
1063     while (( output = mpd_getNextOutput(mi->connection)) != NULL)
1064     {
1065         data = mpd_new_data_struct_append(data);
1066         data->type = MPD_DATA_TYPE_OUTPUT_DEV;
1067         data->output_dev = output;
1068     }
1069     mpd_finishCommand(mi->connection);
1070
1071     /* unlock */
1072     mpd_unlock_conn(mi);
1073     if(data == NULL)
1074     {
1075         return NULL;
1076     }
1077     return mpd_data_get_first(data);
1078 }
1079
1080 int mpd_server_set_output_device(MpdObj *mi,int device_id,int state)
1081 {
1082     if(!mpd_check_connected(mi))
1083     {
1084         debug_printf(DEBUG_WARNING,"not connected\n");
1085         return MPD_NOT_CONNECTED;
1086     }
1087     if(mpd_lock_conn(mi))
1088     {
1089         debug_printf(DEBUG_ERROR,"lock failed\n");
1090         return MPD_LOCK_FAILED;
1091     }
1092     if(state)
1093     {
1094         mpd_sendEnableOutputCommand(mi->connection, device_id);
1095     }
1096     else
1097     {
1098         mpd_sendDisableOutputCommand(mi->connection, device_id);
1099     }
1100     mpd_finishCommand(mi->connection);
1101
1102     mpd_unlock_conn(mi);
1103     mpd_status_queue_update(mi);
1104     return FALSE;
1105 }
1106
1107 int mpd_server_check_version(MpdObj *mi, int major, int minor, int micro)
1108 {
1109     if(!mpd_check_connected(mi))
1110     {
1111         debug_printf(DEBUG_WARNING,"not connected\n");
1112         return FALSE;
1113     }
1114     if(major > mi->connection->version[0]) return FALSE;
1115     if(mi->connection->version[0] > major) return TRUE;
1116     if(minor > mi->connection->version[1]) return FALSE;
1117     if(mi->connection->version[1] > minor) return TRUE;
1118     if(micro > mi->connection->version[2]) return FALSE;
1119     if(mi->connection->version[2] > micro) return TRUE;
1120     return TRUE;
1121 }
1122
1123 int mpd_server_check_command_allowed(MpdObj *mi, const char *command)
1124 {
1125     int i;
1126     if(!mi || !command) return MPD_SERVER_COMMAND_ERROR;
1127     /* when we are connected to a mpd server that doesn't support commands and not commands
1128      * feature. (like mpd 0.11.5) allow everything
1129      */
1130     if(!mpd_server_check_version(mi, 0,12,0)) return MPD_SERVER_COMMAND_ALLOWED;
1131     /*
1132      * Also when somehow we failted to get commands
1133      */
1134     if(mi->commands == NULL) return MPD_SERVER_COMMAND_ALLOWED;
1135
1136
1137
1138     for(i=0;mi->commands[i].command_name;i++)
1139     {
1140         if(!strcasecmp(mi->commands[i].command_name, command))
1141             return mi->commands[i].enabled;
1142     }
1143     return MPD_SERVER_COMMAND_NOT_SUPPORTED;
1144 }
1145
1146 char ** mpd_server_get_url_handlers(MpdObj *mi)
1147 {
1148     char *temp = NULL;
1149     int i=0;
1150     char **retv = NULL;
1151     if(!mpd_check_connected(mi))
1152     {
1153         debug_printf(DEBUG_WARNING,"not connected\n");
1154         return FALSE;
1155     }
1156     if(mpd_lock_conn(mi))
1157     {
1158         debug_printf(DEBUG_ERROR,"lock failed\n");
1159         return NULL;
1160     }
1161     mpd_sendUrlHandlersCommand(mi->connection);
1162     while((temp = mpd_getNextHandler(mi->connection)) != NULL)
1163     {
1164         retv = realloc(retv,(i+2)*sizeof(*retv));
1165         retv[i]   = temp;
1166         retv[i+1] = NULL;
1167         i++;
1168     }
1169     mpd_finishCommand(mi->connection);
1170
1171
1172     mpd_unlock_conn(mi);
1173     return retv;
1174 }
1175 char ** mpd_server_get_tag_types(MpdObj *mi)
1176 {
1177     char *temp = NULL;
1178     int i=0;
1179     char **retv = NULL;
1180     if(!mpd_check_connected(mi))
1181     {
1182         debug_printf(DEBUG_WARNING,"not connected\n");
1183         return FALSE;
1184     }
1185     if(mpd_lock_conn(mi))
1186     {
1187         debug_printf(DEBUG_ERROR,"lock failed\n");
1188         return NULL;
1189     }
1190     mpd_sendTagTypesCommand(mi->connection);
1191     while((temp = mpd_getNextTagType(mi->connection)) != NULL)
1192     {
1193         retv = realloc(retv,(i+2)*sizeof(*retv));
1194         retv[i]   = temp;
1195         retv[i+1] = NULL;
1196         i++;
1197     }
1198     mpd_finishCommand(mi->connection);
1199
1200
1201     mpd_unlock_conn(mi);
1202     return retv;
1203 }
1204
1205 int mpd_misc_get_tag_by_name(char *name)
1206 {
1207     int i;
1208     if(name == NULL)
1209     {
1210         return MPD_ARGS_ERROR;
1211     }
1212     for(i=0; i < MPD_TAG_NUM_OF_ITEM_TYPES; i++)
1213     {
1214         if(!strcasecmp(mpdTagItemKeys[i], name))
1215         {
1216             return i;
1217         }
1218     }
1219     return MPD_TAG_NOT_FOUND;
1220 }
1221
1222 int mpd_server_update_outputs(MpdObj *mi)
1223 {
1224     mpd_OutputEntity *output = NULL;
1225     if(!mpd_check_connected(mi))
1226     {
1227         debug_printf(DEBUG_WARNING,"not connected\n");
1228         return MPD_NOT_CONNECTED;
1229     }
1230     if(mpd_lock_conn(mi))
1231     {
1232         debug_printf(DEBUG_ERROR,"lock failed\n");
1233         return MPD_LOCK_FAILED;
1234     }
1235     mpd_sendOutputsCommand(mi->connection);
1236     while (( output = mpd_getNextOutput(mi->connection)) != NULL)
1237     {
1238         mi->num_outputs++;
1239         mi->output_states = g_realloc(mi->output_states,mi->num_outputs*sizeof(int));
1240         mi->output_states[mi->num_outputs-1] = FALSE;/*output->enabled;*/
1241         mpd_freeOutputElement(output);
1242     }
1243     mpd_finishCommand(mi->connection);
1244     return mpd_unlock_conn(mi);
1245 }
1246
1247 int mpd_server_has_idle(MpdObj *mi)
1248 {
1249     return mi->has_idle;
1250 }
1251
1252 int mpd_server_tag_supported(MpdObj *mi, int tag)
1253 {
1254     if(!mi) return FALSE;
1255     if(tag < 0 || tag >= MPD_TAG_NUM_OF_ITEM_TYPES) {
1256         return FALSE;
1257     }
1258     return mi->supported_tags[tag];
1259 }