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