src/libmpd-database.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 "debug_printf.h"
  28 #include "libmpd.h"
  29 #include "libmpd-internal.h"
  30
  31 int mpd_database_update_dir(MpdObj *mi,const char *path)
  32 {
  33         if(path == NULL || !strlen(path))
  34         {
  35                 debug_printf(DEBUG_ERROR, "path != NULL  and strlen(path) > 0 failed");
  36                 return MPD_ARGS_ERROR;
  37         }
  38         if(!mpd_check_connected(mi))
  39         {
  40                 debug_printf(DEBUG_WARNING,"not connected\n");
  41                 return MPD_NOT_CONNECTED;
  42         }
  43         if(mpd_lock_conn(mi))
  44         {
  45                 debug_printf(DEBUG_ERROR,"lock failed\n");
  46                 return MPD_LOCK_FAILED;
  47         }
  48
  49         mpd_sendUpdateCommand(mi->connection,path);
  50         mpd_finishCommand(mi->connection);
  51         /* I have no idea why do this ?? it even makes gmpc very very unhappy.
  52          * Because it doesnt trigger an signal anymore when updating starts
  53          * mi->CurrentState.updatingDb = mpd_getUpdateId(mi->connection);
  54         */
  55
  56         /* unlock */
  57         mpd_unlock_conn(mi);
  58         /* What I think you should do is to force a direct status updated
  59          */
  60         mpd_status_update(mi);
  61         return MPD_OK;
  62 }
  63
  64 MpdData * mpd_database_get_artists(MpdObj *mi)
  65 {
  66         char *string = NULL;
  67         MpdData *data = NULL;
  68         if(!mpd_check_connected(mi))
  69         {
  70                 debug_printf(DEBUG_WARNING,"not connected\n");
  71                 return NULL;
  72         }
  73         if(mpd_lock_conn(mi))
  74         {
  75                 debug_printf(DEBUG_ERROR,"lock failed\n");
  76                 return NULL;
  77         }
  78
  79         mpd_sendListCommand(mi->connection,MPD_TABLE_ARTIST,NULL);
  80         while (( string = mpd_getNextArtist(mi->connection)) != NULL)
  81         {
  82                 data = mpd_new_data_struct_append(data);
  83                 data->type = MPD_DATA_TYPE_TAG;
  84                 data->tag_type = MPD_TAG_ITEM_ARTIST;
  85                 data->tag = string;
  86         }
  87         mpd_finishCommand(mi->connection);
  88
  89         /* unlock */
  90         mpd_unlock_conn(mi);
  91         if(data == NULL)
  92         {
  93                 return NULL;
  94         }
  95 /*      data = mpd_misc_sort_tag_list(data);*/
  96         return mpd_data_get_first(data);
  97 }
  98
  99 MpdData * mpd_database_get_albums(MpdObj *mi,const char *artist)
 100 {
 101         char *string = NULL;
 102         MpdData *data = NULL;
 103         if(!mpd_check_connected(mi))
 104         {
 105                 debug_printf(DEBUG_WARNING,"not connected\n");
 106                 return NULL;
 107         }
 108         if(mpd_lock_conn(mi))
 109         {
 110                 debug_printf(DEBUG_ERROR,"lock failed\n");
 111                 return NULL;
 112         }
 113
 114         mpd_sendListCommand(mi->connection,MPD_TABLE_ALBUM,artist);
 115         while (( string = mpd_getNextAlbum(mi->connection)) != NULL)
 116         {
 117                 data = mpd_new_data_struct_append(data);
 118                 data->type = MPD_DATA_TYPE_TAG;
 119                 data->tag_type = MPD_TAG_ITEM_ALBUM;
 120                 data->tag = string;
 121         }
 122         mpd_finishCommand(mi->connection);
 123
 124         /* unlock */
 125         mpd_unlock_conn(mi);
 126         if(data == NULL)
 127         {
 128                 return NULL;
 129         }
 130         return mpd_data_get_first(data);
 131 }
 132
 133 MpdData * mpd_database_get_complete(MpdObj *mi)
 134 {
 135         MpdData *data = NULL;
 136         mpd_InfoEntity *ent = NULL;
 137         if(!mpd_check_connected(mi))
 138         {
 139                 debug_printf(DEBUG_WARNING,"not connected\n");
 140                 return NULL;
 141         }
 142         if(mpd_lock_conn(mi))
 143         {
 144                 debug_printf(DEBUG_ERROR,"lock failed\n");
 145                 return NULL;
 146         }
 147         mpd_sendListallInfoCommand(mi->connection, "/");
 148         while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 149         {
 150
 151                 if (ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 152                 {
 153                         data = mpd_new_data_struct_append(data);
 154                         data->type = MPD_DATA_TYPE_SONG;
 155                         data->song = ent->info.song;
 156                         ent->info.song = NULL;
 157                 }
 158                 mpd_freeInfoEntity(ent);
 159         }
 160         mpd_finishCommand(mi->connection);
 161
 162         /* unlock */
 163         mpd_unlock_conn(mi);
 164         if(data == NULL)
 165         {
 166                 return NULL;
 167         }
 168         return mpd_data_get_first(data);
 169 }
 170
 171 int mpd_database_delete_playlist(MpdObj *mi,const char *path)
 172 {
 173         if(path == NULL)
 174         {
 175                 debug_printf(DEBUG_WARNING, "path == NULL");
 176                 return MPD_ARGS_ERROR;
 177         }
 178         if(!mpd_check_connected(mi))
 179         {
 180                 debug_printf(DEBUG_WARNING,"not connected\n");
 181                 return MPD_NOT_CONNECTED;
 182         }
 183         if(mpd_lock_conn(mi))
 184         {
 185                 debug_printf(DEBUG_ERROR,"lock failed\n");
 186                 return MPD_LOCK_FAILED;
 187         }
 188
 189         mpd_sendRmCommand(mi->connection,path);
 190         mpd_finishCommand(mi->connection);
 191
 192         /* unlock */
 193         mpd_unlock_conn(mi);
 194         return MPD_OK;
 195 }
 196
 197 int mpd_database_save_playlist(MpdObj *mi,const char *name)
 198 {
 199         if(name == NULL || !strlen(name))
 200         {
 201                 debug_printf(DEBUG_WARNING, "mpd_playlist_save: name != NULL  and strlen(name) > 0 failed");
 202                 return MPD_ARGS_ERROR;
 203         }
 204         if(!mpd_check_connected(mi))
 205         {
 206                 debug_printf(DEBUG_WARNING,"mpd_playlist_save: not connected\n");
 207                 return MPD_NOT_CONNECTED;
 208         }
 209         if(mpd_lock_conn(mi))
 210         {
 211                 debug_printf(DEBUG_ERROR,"mpd_playlist_save: lock failed\n");
 212                 return MPD_LOCK_FAILED;
 213         }
 214
 215         mpd_sendSaveCommand(mi->connection,name);
 216         mpd_finishCommand(mi->connection);
 217         if(mi->connection->error == MPD_ERROR_ACK && mi->connection->errorCode == MPD_ACK_ERROR_EXIST)
 218         {
 219                 mpd_clearError(mi->connection);
 220                 mpd_unlock_conn(mi);
 221                 return MPD_DATABASE_PLAYLIST_EXIST;
 222
 223         }
 224         /* unlock */
 225         mpd_unlock_conn(mi);
 226         return MPD_OK;
 227 }
 228
 229 /* "hack" to keep the compiler happy */
 230 typedef int (* QsortCompare)(const void *a, const void *b);
 231
 232 static int compa(char **a,const char **b)
 233 {
 234         char *c =*a;
 235         char *d =(char*)*b;
 236 #ifndef NO_SMART_SORT
 237         if(!strncasecmp(c, "The ",4) && strlen(c) > 4)
 238         {
 239                 c = &c[4];
 240         }
 241         if(!strncasecmp(d, "The ",4) && strlen(d) > 4)
 242         {
 243                 d = &d[4];
 244         }
 245 #endif
 246
 247         return strcasecmp(c,d);
 248 }
 249
 250 MpdData *mpd_misc_sort_tag_list(MpdData *data)
 251 {
 252         char **array;
 253         MpdData *test;
 254         int i=0;
 255         int length=0;
 256         test = data = mpd_data_get_first(data);
 257
 258         do{
 259                 length++;
 260                 test = mpd_data_get_next_real(test, FALSE);
 261         }while(test != NULL);
 262         array = malloc(length*sizeof(char*));
 263         test = data;
 264
 265         do
 266         {
 267                 array[i] = test->tag;
 268                 test = mpd_data_get_next_real(test, FALSE);
 269                 i++;
 270         }while(test != NULL);
 271
 272         qsort(array,length,sizeof(char *),(QsortCompare)compa);
 273
 274         /* reset list */
 275         test = mpd_data_get_first(data);
 276         i=0;
 277         do
 278         {
 279                 test->tag = array[i];
 280                 test = mpd_data_get_next_real(test, FALSE);
 281                 i++;
 282         }while(test != NULL);
 283         free(array);
 284         return mpd_data_get_first(data);
 285 }
 286
 287 /* should be called mpd_database_find */
 288 MpdData * mpd_database_find(MpdObj *mi, int table,const char *string, int exact)
 289 {
 290         MpdData *data = NULL;
 291 /*      MpdData *artist = NULL;
 292         MpdData *album = NULL;
 293 */      mpd_InfoEntity *ent = NULL;
 294         if(!mpd_check_connected(mi))
 295         {
 296                 debug_printf(DEBUG_WARNING,"not connected\n");
 297                 return NULL;
 298         }
 299         if(mpd_lock_conn(mi))
 300         {
 301                 debug_printf(DEBUG_WARNING,"lock failed\n");
 302                 return NULL;
 303         }
 304         if(exact)
 305         {
 306                 mpd_sendFindCommand(mi->connection,table,string);
 307         }
 308         else
 309         {
 310                 mpd_sendSearchCommand(mi->connection, table,string);
 311         }
 312         while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 313         {
 314                 data = mpd_new_data_struct_append(data);
 315                 /* mpd_sendSearch|Find only returns songs */
 316                 /*
 317                 if(ent->type == MPD_INFO_ENTITY_TYPE_DIRECTORY)
 318                 {
 319                         data->type = MPD_DATA_TYPE_DIRECTORY;
 320                         data->directory = ent->info.directory->path;
 321                         ent->info.directory->path = NULL;
 322                 }
 323                 else*/ if (ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 324                 {
 325                         data->type = MPD_DATA_TYPE_SONG;
 326                         data->song = ent->info.song;
 327                         ent->info.song = NULL;
 328                         /* This is something the client can and should do */
 329 /*                      if(data->song->artist != NULL)
 330                         {
 331                                 int found = FALSE;
 332                                 if(artist != NULL)
 333                                 {
 334                                         MpdData *fartist = mpd_data_get_first(artist);
 335                                         do{
 336                                                 if( (fartist->type == MPD_DATA_TYPE_TAG) && (fartist->tag_type == MPD_TAG_ITEM_ARTIST))
 337                                                 {
 338                                                         if(fartist->tag == NULL)
 339                                                         {
 340                                                                 printf("crap this should'nt be \n");
 341                                                         }
 342                                                         if(!strcmp(fartist->tag, data->song->artist))
 343                                                         {
 344                                                                 found = TRUE;
 345                                                         }
 346                                                 }
 347                                                 fartist = mpd_data_get_next_real(fartist, FALSE);
 348                                         }while(fartist && !found);
 349                                 }
 350                                 if(!found)
 351                                 {
 352                                         artist= mpd_new_data_struct_append(artist);
 353                                         artist->type = MPD_DATA_TYPE_TAG;
 354                                         artist->tag_type = MPD_TAG_ITEM_ARTIST;
 355                                         artist->tag = strdup(data->song->artist);
 356                                 }
 357                         }
 358                         if(data->song->album != NULL)
 359                         {
 360                                 int found = FALSE;
 361                                 if(album != NULL)
 362                                 {
 363                                         MpdData *falbum = mpd_data_get_first(album);
 364                                         do{
 365                                                 if( (falbum->type == MPD_DATA_TYPE_TAG) && (falbum->tag_type == MPD_TAG_ITEM_ALBUM))
 366                                                 {
 367                                                         if(falbum->tag == NULL)
 368                                                         {
 369                                                                 printf("crap this should'nt be \n");
 370                                                         }
 371                                                         if(!strcmp(falbum->tag, data->song->album))
 372                                                         {
 373                                                                 found = TRUE;
 374                                                         }
 375                                                 }
 376                                                 falbum = mpd_data_get_next_real(falbum, FALSE);
 377                                         }while(falbum && !found);
 378                                 }
 379                                 if(!found)
 380                                 {
 381                                         album = mpd_new_data_struct_append(album);
 382                                         album->type = MPD_DATA_TYPE_TAG;
 383                                         album->tag_type = MPD_TAG_ITEM_ALBUM;
 384                                         album->tag = strdup(data->song->album);
 385                                 }
 386                         }
 387 */
 388                 }
 389                 /*
 390                 else if (ent->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE)
 391                 {
 392                         data->type = MPD_DATA_TYPE_PLAYLIST;
 393                         data->playlist = ent->info.playlistFile->path;
 394                         ent->info.playlistFile->path = NULL;
 395                 }
 396                 */
 397
 398                 mpd_freeInfoEntity(ent);
 399         }
 400         mpd_finishCommand(mi->connection);
 401
 402         /* unlock */
 403         mpd_unlock_conn(mi);
 404         if(data == NULL)
 405         {
 406                 return NULL;
 407         }
 408         data = mpd_data_get_first(data);
 409         /* prepend the album then artists*/
 410 /*      if(album != NULL)
 411         {
 412                 if(data){
 413                         data  = mpd_data_concatenate( album, data);
 414                 }else{
 415                         data = album;
 416                 }
 417         }
 418         if(artist != NULL)
 419         {
 420                 if(data) {
 421                         album = mpd_data_concatenate( artist, data );
 422                 }else{
 423                         data = artist;
 424                 }
 425         }
 426 */
 427         return mpd_data_get_first(data);
 428 }
 429
 430 MpdData * mpd_database_get_directory(MpdObj *mi,const char *path)
 431 {
 432         MpdData *data = NULL;
 433         mpd_InfoEntity *ent = NULL;
 434         if(!mpd_check_connected(mi))
 435         {
 436                 debug_printf(DEBUG_WARNING,"not connected\n");
 437                 return NULL;
 438         }
 439         if(path == NULL)
 440         {
 441                 path = "/";
 442         }
 443         if(mpd_lock_conn(mi))
 444         {
 445                 debug_printf(DEBUG_WARNING,"lock failed\n");
 446                 return NULL;
 447         }
 448
 449         mpd_sendLsInfoCommand(mi->connection,path);
 450         while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 451         {
 452                 data = mpd_new_data_struct_append(data);
 453                 if(ent->type == MPD_INFO_ENTITY_TYPE_DIRECTORY)
 454                 {
 455                         data->type = MPD_DATA_TYPE_DIRECTORY;
 456                         data->directory = ent->info.directory->path;
 457                         ent->info.directory->path = NULL;
 458                 }
 459                 else if (ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 460                 {
 461                         data->type = MPD_DATA_TYPE_SONG;
 462                         data->song = ent->info.song;
 463                         ent->info.song = NULL;
 464                 }
 465                 else if (ent->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE)
 466                 {
 467                         data->type = MPD_DATA_TYPE_PLAYLIST;
 468                         data->playlist = ent->info.playlistFile;
 469                         ent->info.playlistFile= NULL;
 470                 }
 471
 472                 mpd_freeInfoEntity(ent);
 473         }
 474         mpd_finishCommand(mi->connection);
 475
 476         /* unlock */
 477         mpd_unlock_conn(mi);
 478         if(data == NULL)
 479         {
 480                 return NULL;
 481         }
 482         return mpd_data_get_first(data);
 483 }
 484
 485 MpdData *mpd_database_get_playlist_content(MpdObj *mi,const char *playlist)
 486 {
 487         MpdData *data = NULL;
 488         mpd_InfoEntity *ent = NULL;
 489         if(!mpd_check_connected(mi))
 490         {
 491                 debug_printf(DEBUG_WARNING,"not connected\n");
 492                 return NULL;
 493         }
 494         if(!mpd_server_check_version(mi, 0,12,0))
 495         {
 496                 debug_printf(DEBUG_WARNING, "only works with mpd higher then 0.12.0");
 497                 return NULL;
 498         }
 499         if(mpd_server_check_command_allowed(mi, "listplaylistinfo") != MPD_SERVER_COMMAND_ALLOWED)
 500         {
 501                 debug_printf(DEBUG_WARNING, "Listing playlist content not supported or allowed");
 502                 return NULL;
 503         }
 504         if(mpd_lock_conn(mi))
 505         {
 506                 debug_printf(DEBUG_WARNING,"lock failed\n");
 507                 return NULL;
 508         }
 509         mpd_sendListPlaylistInfoCommand(mi->connection, playlist);
 510         while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 511         {
 512                 data = mpd_new_data_struct_append( data );
 513                 if(ent->type == MPD_INFO_ENTITY_TYPE_DIRECTORY)
 514                 {
 515                         data->type = MPD_DATA_TYPE_DIRECTORY;
 516                         data->directory = ent->info.directory->path;
 517                         ent->info.directory->path = NULL;
 518                 }
 519                 else if (ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 520                 {
 521                         data->type = MPD_DATA_TYPE_SONG;
 522                         data->song = ent->info.song;
 523                         ent->info.song = NULL;
 524                 }
 525                 else if (ent->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE)
 526                 {
 527                         data->type = MPD_DATA_TYPE_PLAYLIST;
 528                         data->playlist = ent->info.playlistFile;
 529                         ent->info.playlistFile= NULL;
 530                 }
 531
 532                 mpd_freeInfoEntity(ent);
 533         }
 534         mpd_finishCommand(mi->connection);
 535
 536         /* unlock */
 537         mpd_unlock_conn(mi);
 538         if(data == NULL)
 539         {
 540                 return NULL;
 541         }
 542         return mpd_data_get_first(data);
 543 }
 544 /**
 545  * @param mi A #MpdObj
 546  * @param path an Path to a file
 547  *
 548  * Grabs the song info for a single file. Make sure you pass an url to a song
 549  * and not a directory, that might result in strange behauviour.
 550  *
 551  * @returns a #mpd_Song
 552  */
 553 mpd_Song * mpd_database_get_fileinfo(MpdObj *mi,const char *path)
 554 {
 555         mpd_Song *song = NULL;
 556         mpd_InfoEntity *ent = NULL;
 557         /*
 558          * Check path for availibility and length
 559          */
 560         if(path == NULL || path[0] == '\0')
 561         {
 562                 debug_printf(DEBUG_ERROR, "path == NULL || strlen(path) == 0");
 563                 return NULL;
 564         }
 565         if(!mpd_check_connected(mi))
 566         {
 567                 debug_printf(DEBUG_ERROR, "Not Connected\n");
 568                 return NULL;
 569         }
 570         /* lock, so we can work on mi->connection */
 571         if(mpd_lock_conn(mi) != MPD_OK)
 572         {
 573                 debug_printf(DEBUG_ERROR, "Failed to lock connection");
 574                 return NULL;
 575         }
 576         /* send the request */
 577         mpd_sendListallInfoCommand(mi->connection, path);
 578         /* get the first (and only) result */
 579         ent = mpd_getNextInfoEntity(mi->connection);
 580         /* finish and clean up libmpdclient */
 581         mpd_finishCommand(mi->connection);
 582         /* unlock again */
 583         if(mpd_unlock_conn(mi))
 584         {
 585                 if(ent) mpd_freeInfoEntity(ent);
 586                 debug_printf(DEBUG_ERROR, "Failed to unlock");
 587                 return NULL;
 588         }
 589
 590         if(ent == NULL)
 591         {
 592                 debug_printf(DEBUG_ERROR, "Failed to grab song from mpd\n");
 593                 return NULL;
 594         }
 595
 596         if(ent->type != MPD_INFO_ENTITY_TYPE_SONG)
 597         {
 598                 mpd_freeInfoEntity(ent);
 599                 debug_printf(DEBUG_ERROR, "Failed to grab correct song type from mpd, path might not be a file\n");
 600                 return NULL;
 601         }
 602         /* get the song */
 603         song = ent->info.song;
 604         /* remove reference to song from the entity */
 605         ent->info.song = NULL;
 606         /* free the entity */
 607         mpd_freeInfoEntity(ent);
 608
 609         return song;
 610 }
 611
 612
 613 void mpd_database_search_field_start(MpdObj *mi, mpd_TagItems field)
 614 {
 615         /*
 616          * Check argument
 617          */
 618         if(mi == NULL || field >= MPD_TAG_NUM_OF_ITEM_TYPES || field < 0)
 619         {
 620                 debug_printf(DEBUG_ERROR, "Argument error");
 621                 return ;
 622         }
 623         if(!mpd_check_connected(mi))
 624         {
 625                 debug_printf(DEBUG_ERROR, "Not Connected\n");
 626                 return ;
 627         }
 628         if(!mpd_server_check_version(mi, 0,12,0))
 629         {
 630                 debug_printf(DEBUG_ERROR, "Advanced field list requires mpd 0.12.0 or higher");
 631                 return ;
 632         }
 633         /* lock, so we can work on mi->connection */
 634         if(mpd_lock_conn(mi) != MPD_OK)
 635         {
 636                 debug_printf(DEBUG_ERROR, "Failed to lock connection");
 637                 return ;
 638         }
 639         mpd_startFieldSearch(mi->connection, field);
 640         /* Set search type */
 641         mi->search_type = MPD_SEARCH_TYPE_LIST;
 642         mi->search_field = field;
 643         /* unlock, let the error handler handle any possible error.
 644          */
 645         mpd_unlock_conn(mi);
 646         return;
 647 }
 648
 649
 650
 651
 652
 653
 654
 655 /**
 656  * @param mi A #MpdObj
 657  * @param exact a boolean indicating if the search is fuzzy or exact
 658  *
 659  * Starts a search, you can add "constraints" by calling mpd_database_search_add_constraint
 660  *
 661  * This function requires mpd 0.12.0 or higher
 662  */
 663
 664 void mpd_database_search_start(MpdObj *mi, int exact)
 665 {
 666         /*
 667          * Check argument
 668          */
 669         if(mi == NULL || exact > 1 || exact < 0)
 670         {
 671                 debug_printf(DEBUG_ERROR, "Argument error");
 672                 return ;
 673         }
 674         if(!mpd_check_connected(mi))
 675         {
 676                 debug_printf(DEBUG_ERROR, "Not Connected\n");
 677                 return ;
 678         }
 679         if(!mpd_server_check_version(mi, 0,12,0))
 680         {
 681                 debug_printf(DEBUG_ERROR, "Advanced search requires mpd 0.12.0 or higher");
 682                 return ;
 683         }
 684         /* lock, so we can work on mi->connection */
 685         if(mpd_lock_conn(mi) != MPD_OK)
 686         {
 687                 debug_printf(DEBUG_ERROR, "Failed to lock connection");
 688                 return ;
 689         }
 690         mpd_startSearch(mi->connection, exact);
 691         /* Set search type */
 692         mi->search_type = (exact)? MPD_SEARCH_TYPE_FIND:MPD_SEARCH_TYPE_SEARCH;
 693         /* unlock, let the error handler handle any possible error.
 694          */
 695         mpd_unlock_conn(mi);
 696         return;
 697 }
 698 /**
 699  * @param mi A #MpdObj
 700  * @param field A #mpd_TagItems
 701  *
 702  * Adds a constraint to the search
 703  */
 704 void mpd_database_search_add_constraint(MpdObj *mi, mpd_TagItems field, const char *value)
 705 {
 706         if(mi == NULL || value == NULL )
 707         {
 708                 debug_printf(DEBUG_ERROR,"Failed to parse arguments");
 709                 return;
 710         }
 711         if(mi->search_type == MPD_SEARCH_TYPE_NONE)
 712         {
 713                 debug_printf(DEBUG_ERROR, "No search to constraint");
 714                 return;
 715         }
 716         if(!mpd_check_connected(mi))
 717         {
 718                 debug_printf(DEBUG_ERROR, "Not Connected\n");
 719                 return ;
 720         }
 721         if(!mpd_server_check_version(mi, 0,12,0))
 722         {
 723                 debug_printf(DEBUG_ERROR, "Advanced search requires mpd 0.12.0 or higher");
 724                 return ;
 725         }
 726         /* lock, so we can work on mi->connection */
 727         if(mpd_lock_conn(mi) != MPD_OK)
 728         {
 729                 debug_printf(DEBUG_ERROR, "Failed to lock connection");
 730                 return ;
 731         }
 732         mpd_addConstraintSearch(mi->connection, field, value);
 733         /* unlock, let the error handler handle any possible error.
 734          */
 735         mpd_unlock_conn(mi);
 736         return;
 737 }
 738
 739 MpdData * mpd_database_search_commit(MpdObj *mi)
 740 {
 741         mpd_InfoEntity *ent = NULL;
 742         MpdData *data = NULL;
 743         if(!mpd_check_connected(mi))
 744         {
 745                 debug_printf(DEBUG_WARNING,"not connected\n");
 746                 return NULL;
 747         }
 748         if(mi->search_type == MPD_SEARCH_TYPE_NONE)
 749         {
 750                 debug_printf(DEBUG_ERROR, "no search in progress to commit");
 751                 return NULL;
 752         }
 753         if(mpd_lock_conn(mi))
 754         {
 755                 debug_printf(DEBUG_ERROR,"lock failed\n");
 756                 return NULL;
 757         }
 758         mpd_commitSearch(mi->connection);
 759         if(mi->search_type == MPD_SEARCH_TYPE_LIST)
 760         {
 761                 char *string = NULL;
 762                 while((string = mpd_getNextTag(mi->connection, mi->search_field)))
 763                 {
 764                         data = mpd_new_data_struct_append(data);
 765                         data->type = MPD_DATA_TYPE_TAG;
 766                         data->tag_type = mi->search_field;
 767                         data->tag = string;
 768                 }
 769         }
 770         else
 771         {
 772                 while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 773                 {
 774                         if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 775                         {
 776                                 data = mpd_new_data_struct_append(data);
 777                                 data->type = MPD_DATA_TYPE_SONG;
 778                                 data->song = ent->info.song;
 779                                 ent->info.song = NULL;
 780                         }
 781                         mpd_freeInfoEntity(ent);
 782                 }
 783         }
 784         mpd_finishCommand(mi->connection);
 785         /*
 786          * reset search type
 787          */
 788         mi->search_type = MPD_SEARCH_TYPE_NONE;
 789         mi->search_field = MPD_TAG_ITEM_ARTIST;
 790         /* unlock */
 791         if(mpd_unlock_conn(mi))
 792         {
 793                 debug_printf(DEBUG_ERROR, "Failed to unlock connection");
 794                 if(data)mpd_data_free(data);
 795                 return NULL;
 796         }
 797         if(data == NULL)
 798         {
 799                 return NULL;
 800         }
 801         return mpd_data_get_first(data);
 802 }
 803
 804 /**
 805  * @param mi A #MpdObj
 806  *
 807  * Starts a search, you can add "constraints" by calling mpd_database_search_add_constraint
 808  * to get the result call mpd_database_search_stats_commit
 809  *
 810  * This function requires mpd 0.13.0 or higher
 811  */
 812
 813 void mpd_database_search_stats_start(MpdObj *mi)
 814 {
 815         /*
 816          * Check argument
 817          */
 818         if(mi == NULL)
 819         {
 820                 debug_printf(DEBUG_ERROR, "Argument error");
 821                 return ;
 822         }
 823         if(!mpd_check_connected(mi))
 824         {
 825                 debug_printf(DEBUG_ERROR, "Not Connected\n");
 826                 return ;
 827         }
 828         if(!mpd_server_check_version(mi, 0,13,0))
 829         {
 830                 debug_printf(DEBUG_ERROR, "Advanced search requires mpd 0.13.0 or higher");
 831                 return ;
 832         }
 833         /* lock, so we can work on mi->connection */
 834         if(mpd_lock_conn(mi) != MPD_OK)
 835         {
 836                 debug_printf(DEBUG_ERROR, "Failed to lock connection");
 837                 return ;
 838         }
 839         mpd_startStatsSearch(mi->connection);
 840         /* Set search type */
 841         mi->search_type = MPD_SEARCH_TYPE_STATS;
 842         /* unlock, let the error handler handle any possible error.
 843          */
 844         mpd_unlock_conn(mi);
 845         return;
 846 }
 847
 848 MpdDBStats * mpd_database_search_stats_commit(MpdObj *mi)
 849 {
 850         MpdDBStats *data = NULL;
 851         if(!mpd_check_connected(mi))
 852         {
 853                 debug_printf(DEBUG_WARNING,"not connected\n");
 854                 return NULL;
 855         }
 856         if(mi->search_type != MPD_SEARCH_TYPE_STATS)
 857         {
 858                 debug_printf(DEBUG_ERROR, "no/wrong search in progress to commit");
 859                 return NULL;
 860         }
 861         if(mpd_lock_conn(mi))
 862         {
 863                 debug_printf(DEBUG_ERROR,"lock failed\n");
 864                 return NULL;
 865         }
 866         mpd_commitSearch(mi->connection);
 867
 868         data = (MpdDBStats *) mpd_getSearchStats(mi->connection);
 869         /* unlock */
 870         if(mpd_unlock_conn(mi))
 871         {
 872                 debug_printf(DEBUG_ERROR, "Failed to unlock connection");
 873                 if(data)mpd_freeSearchStats((mpd_SearchStats *)data);
 874                 return NULL;
 875         }
 876         if(data == NULL)
 877         {
 878                 return NULL;
 879         }
 880         return data;
 881 }
 882
 883 void mpd_database_search_free_stats(MpdDBStats *data)
 884 {
 885         mpd_freeSearchStats(data);
 886 }
 887
 888 void mpd_database_playlist_clear(MpdObj *mi, const char *path)
 889 {
 890         if(!path )
 891                 return;
 892         if (!mpd_check_connected(mi)) {
 893                 debug_printf(DEBUG_WARNING, "not connected\n");
 894                 return;
 895         }
 896         if (mpd_status_check(mi) != MPD_OK) {
 897                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 898                 return;
 899         }
 900         if(mpd_lock_conn(mi))
 901         {
 902                 return ;
 903         }
 904
 905         mpd_sendPlaylistClearCommand(mi->connection, (char *)path);
 906         mpd_finishCommand(mi->connection);
 907
 908         mpd_unlock_conn(mi);
 909 }
 910
 911
 912
 913
 914
 915
 916 void mpd_database_playlist_list_delete(MpdObj *mi, const char *path, int pos)
 917 {
 918         if(!path )
 919                 return;
 920         if (!mpd_check_connected(mi)) {
 921                 debug_printf(DEBUG_WARNING, "not connected\n");
 922                 return;
 923         }
 924         if (mpd_status_check(mi) != MPD_OK) {
 925                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 926                 return;
 927         }
 928         if(mpd_lock_conn(mi))
 929         {
 930                 return ;
 931         }
 932
 933         mpd_sendPlaylistDeleteCommand(mi->connection, (char *)path,pos);
 934         mpd_finishCommand(mi->connection);
 935
 936         mpd_unlock_conn(mi);
 937 }
 938 void mpd_database_playlist_list_add(MpdObj *mi, const char *path, const char *file)
 939 {
 940         if(!path )
 941                 return;
 942         if (!mpd_check_connected(mi)) {
 943                 debug_printf(DEBUG_WARNING, "not connected\n");
 944                 return;
 945         }
 946         if (mpd_status_check(mi) != MPD_OK) {
 947                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
 948                 return;
 949         }
 950         if(mpd_lock_conn(mi))
 951         {
 952                 return ;
 953         }
 954
 955         mpd_sendPlaylistAddCommand(mi->connection, (char *)path,(char *)file);
 956         mpd_finishCommand(mi->connection);
 957
 958         mpd_unlock_conn(mi);
 959 }
 960
 961 MpdData * mpd_database_get_directory_recursive(MpdObj *mi, const char *path)
 962 {
 963         MpdData *data = NULL;
 964         mpd_InfoEntity *ent = NULL;
 965         if(!mpd_check_connected(mi))
 966         {
 967                 debug_printf(DEBUG_WARNING,"not connected\n");
 968                 return NULL;
 969         }
 970         if(path == '\0' || path[0] == '\0')
 971         {
 972                 debug_printf(DEBUG_ERROR, "argumant invalid\n");
 973                 return NULL;
 974         }
 975         if(mpd_lock_conn(mi))
 976         {
 977                 debug_printf(DEBUG_ERROR,"lock failed\n");
 978                 return NULL;
 979         }
 980         mpd_sendListallInfoCommand(mi->connection,path);
 981         while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
 982         {
 983
 984                 if (ent->type == MPD_INFO_ENTITY_TYPE_SONG)
 985                 {
 986                         data = mpd_new_data_struct_append(data);
 987                         data->type = MPD_DATA_TYPE_SONG;
 988                         data->song = ent->info.song;
 989                         ent->info.song = NULL;
 990                 }
 991                 mpd_freeInfoEntity(ent);
 992         }
 993         mpd_finishCommand(mi->connection);
 994
 995         /* unlock */
 996         mpd_unlock_conn(mi);
 997         if(data == NULL)
 998         {
 999                 return NULL;
1000         }
1001         return mpd_data_get_first(data);
1002 }
1003 void mpd_database_playlist_rename(MpdObj *mi, const char *old_name, const char *new_name)
1004 {
1005         if(!new_name || !old_name)
1006         {
1007                 debug_printf(DEBUG_ERROR, "old != NULL && new != NULL failed");
1008                 return;
1009         }
1010         if (!mpd_check_connected(mi)) {
1011                 debug_printf(DEBUG_WARNING, "not connected\n");
1012                 return;
1013         }
1014         if (mpd_status_check(mi) != MPD_OK) {
1015                 debug_printf(DEBUG_WARNING, "Failed to get status\n");
1016                 return;
1017         }
1018         if(mpd_lock_conn(mi))
1019         {
1020                 return ;
1021         }
1022
1023         mpd_sendRenameCommand(mi->connection, (char *)old_name,(char *)new_name);
1024         mpd_finishCommand(mi->connection);
1025
1026         mpd_unlock_conn(mi);
1027 }
1028
1029 int mpd_database_playlist_move(MpdObj *mi, const char *playlist, int old_pos, int new_pos)
1030 {
1031         if(!mpd_check_connected(mi))
1032         {
1033                 debug_printf(DEBUG_WARNING,"not connected\n");
1034                 return MPD_NOT_CONNECTED;
1035         }
1036         if(mpd_lock_conn(mi))
1037         {
1038                 debug_printf(DEBUG_ERROR,"lock failed\n");
1039                 return MPD_LOCK_FAILED;
1040         }
1041
1042         mpd_sendPlaylistMoveCommand(mi->connection,(char *)playlist,old_pos, new_pos);
1043         mpd_finishCommand(mi->connection);
1044
1045         /* unlock */
1046         mpd_unlock_conn(mi);
1047         return MPD_OK;
1048 }
1049
1050
1051 MpdData * mpd_database_playlist_list(MpdObj *mi)
1052 {
1053         MpdData *data = NULL;
1054         mpd_InfoEntity *ent = NULL;
1055         if(!mpd_check_connected(mi))
1056         {
1057                 debug_printf(DEBUG_WARNING,"not connected\n");
1058                 return NULL;
1059         }
1060         if(mpd_lock_conn(mi))
1061         {
1062                 debug_printf(DEBUG_ERROR,"lock failed\n");
1063                 return NULL;
1064         }
1065     if(mpd_server_check_command_allowed(mi, "listplaylists") == MPD_SERVER_COMMAND_ALLOWED)
1066     {
1067         mpd_sendListPlaylistsCommand(mi->connection);
1068     }
1069     else
1070     {
1071         mpd_sendLsInfoCommand (mi->connection ,"/");
1072     }
1073     while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
1074     {
1075
1076         if (ent->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE)
1077         {
1078             data = mpd_new_data_struct_append(data);
1079             data->type = MPD_DATA_TYPE_PLAYLIST;
1080             data->playlist= ent->info.playlistFile;
1081             ent->info.playlistFile = NULL;
1082         }
1083         mpd_freeInfoEntity(ent);
1084     }
1085     mpd_finishCommand(mi->connection);
1086
1087         /* unlock */
1088         mpd_unlock_conn(mi);
1089         if(data == NULL)
1090         {
1091                 return NULL;
1092         }
1093         return mpd_data_get_first(data);
1094 }