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