src/mpdclient.c

   1 /* ncmpc (Ncurses MPD Client)
   2  * (c) 2004-2009 The Music Player Daemon Project
   3  * Project homepage: http://musicpd.org
   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 "mpdclient.h"
  21 #include "filelist.h"
  22 #include "screen_client.h"
  23 #include "config.h"
  24 #include "options.h"
  25 #include "strfsong.h"
  26 #include "utils.h"
  27
  28 #include <mpd/client.h>
  29
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #include <time.h>
  33 #include <string.h>
  34
  35 #define BUFSIZE 1024
  36
  37 static bool
  38 MPD_ERROR(const struct mpdclient *client)
  39 {
  40         return client->connection == NULL ||
  41                 mpd_connection_get_error(client->connection) != MPD_ERROR_SUCCESS;
  42 }
  43
  44 /* filelist sorting functions */
  45 static gint
  46 compare_filelistentry(gconstpointer filelist_entry1,
  47                           gconstpointer filelist_entry2)
  48 {
  49         const struct mpd_entity *e1, *e2;
  50         int n = 0;
  51
  52         e1 = ((const struct filelist_entry *)filelist_entry1)->entity;
  53         e2 = ((const struct filelist_entry *)filelist_entry2)->entity;
  54
  55         if (e1 != NULL && e2 != NULL &&
  56             mpd_entity_get_type(e1) == mpd_entity_get_type(e2)) {
  57                 switch (mpd_entity_get_type(e1)) {
  58                 case MPD_ENTITY_TYPE_UNKNOWN:
  59                         break;
  60                 case MPD_ENTITY_TYPE_DIRECTORY:
  61                         n = g_utf8_collate(mpd_directory_get_path(mpd_entity_get_directory(e1)),
  62                                            mpd_directory_get_path(mpd_entity_get_directory(e2)));
  63                         break;
  64                 case MPD_ENTITY_TYPE_SONG:
  65                         break;
  66                 case MPD_ENTITY_TYPE_PLAYLIST:
  67                         n = g_utf8_collate(mpd_playlist_get_path(mpd_entity_get_playlist(e1)),
  68                                            mpd_playlist_get_path(mpd_entity_get_playlist(e2)));
  69                 }
  70         }
  71         return n;
  72 }
  73
  74 /* sort by list-format */
  75 gint
  76 compare_filelistentry_format(gconstpointer filelist_entry1,
  77                              gconstpointer filelist_entry2)
  78 {
  79         const struct mpd_entity *e1, *e2;
  80         char key1[BUFSIZE], key2[BUFSIZE];
  81         int n = 0;
  82
  83         e1 = ((const struct filelist_entry *)filelist_entry1)->entity;
  84         e2 = ((const struct filelist_entry *)filelist_entry2)->entity;
  85
  86         if (e1 && e2 &&
  87             mpd_entity_get_type(e1) == MPD_ENTITY_TYPE_SONG &&
  88             mpd_entity_get_type(e2) == MPD_ENTITY_TYPE_SONG) {
  89                 strfsong(key1, BUFSIZE, options.list_format, mpd_entity_get_song(e1));
  90                 strfsong(key2, BUFSIZE, options.list_format, mpd_entity_get_song(e2));
  91                 n = strcmp(key1,key2);
  92         }
  93
  94         return n;
  95 }
  96
  97
  98 /****************************************************************************/
  99 /*** mpdclient functions ****************************************************/
 100 /****************************************************************************/
 101
 102 gint
 103 mpdclient_handle_error(struct mpdclient *c)
 104 {
 105         enum mpd_error error = mpd_connection_get_error(c->connection);
 106
 107         assert(error != MPD_ERROR_SUCCESS);
 108
 109         if (error == MPD_ERROR_SERVER &&
 110             mpd_connection_get_server_error(c->connection) == MPD_SERVER_ERROR_PERMISSION &&
 111             screen_auth(c))
 112                 return 0;
 113
 114         if (error == MPD_ERROR_SERVER)
 115                 error = error | (mpd_connection_get_server_error(c->connection) << 8);
 116
 117         mpdclient_ui_error(mpd_connection_get_error_message(c->connection));
 118
 119         if (!mpd_connection_clear_error(c->connection))
 120                 mpdclient_disconnect(c);
 121
 122         return error;
 123 }
 124
 125 static gint
 126 mpdclient_finish_command(struct mpdclient *c)
 127 {
 128         return mpd_response_finish(c->connection)
 129                 ? 0 : mpdclient_handle_error(c);
 130 }
 131
 132 struct mpdclient *
 133 mpdclient_new(void)
 134 {
 135         struct mpdclient *c;
 136
 137         c = g_new0(struct mpdclient, 1);
 138         playlist_init(&c->playlist);
 139         c->volume = -1;
 140         c->events = 0;
 141
 142         return c;
 143 }
 144
 145 void
 146 mpdclient_free(struct mpdclient *c)
 147 {
 148         mpdclient_disconnect(c);
 149
 150         mpdclient_playlist_free(&c->playlist);
 151
 152         g_free(c);
 153 }
 154
 155 void
 156 mpdclient_disconnect(struct mpdclient *c)
 157 {
 158         if (c->connection)
 159                 mpd_connection_free(c->connection);
 160         c->connection = NULL;
 161
 162         if (c->status)
 163                 mpd_status_free(c->status);
 164         c->status = NULL;
 165
 166         playlist_clear(&c->playlist);
 167
 168         if (c->song)
 169                 c->song = NULL;
 170 }
 171
 172 bool
 173 mpdclient_connect(struct mpdclient *c,
 174                   const gchar *host,
 175                   gint port,
 176                   gfloat _timeout,
 177                   const gchar *password)
 178 {
 179         /* close any open connection */
 180         if( c->connection )
 181                 mpdclient_disconnect(c);
 182
 183         /* connect to MPD */
 184         c->connection = mpd_connection_new(host, port, _timeout * 1000);
 185         if (c->connection == NULL)
 186                 g_error("Out of memory");
 187
 188         if (mpd_connection_get_error(c->connection) != MPD_ERROR_SUCCESS) {
 189                 mpdclient_handle_error(c);
 190                 mpdclient_disconnect(c);
 191                 return false;
 192         }
 193
 194         /* send password */
 195         if (password != NULL && !mpd_run_password(c->connection, password)) {
 196                 mpdclient_handle_error(c);
 197                 mpdclient_disconnect(c);
 198                 return false;
 199         }
 200
 201         return true;
 202 }
 203
 204 bool
 205 mpdclient_update(struct mpdclient *c)
 206 {
 207         bool retval;
 208
 209         c->volume = -1;
 210
 211         if (MPD_ERROR(c))
 212                 return false;
 213
 214         /* always announce these options as long as we don't have real
 215            "idle" support */
 216         c->events |= MPD_IDLE_PLAYER|MPD_IDLE_OPTIONS;
 217
 218         /* free the old status */
 219         if (c->status)
 220                 mpd_status_free(c->status);
 221
 222         /* retrieve new status */
 223         c->status = mpd_run_status(c->connection);
 224         if (c->status == NULL)
 225                 return mpdclient_handle_error(c) == 0;
 226
 227         if (c->update_id != mpd_status_get_update_id(c->status)) {
 228                 c->events |= MPD_IDLE_UPDATE;
 229
 230                 if (c->update_id > 0)
 231                         c->events |= MPD_IDLE_DATABASE;
 232         }
 233
 234         c->update_id = mpd_status_get_update_id(c->status);
 235
 236         if (c->volume != mpd_status_get_volume(c->status))
 237                 c->events |= MPD_IDLE_MIXER;
 238
 239         c->volume = mpd_status_get_volume(c->status);
 240
 241         /* check if the playlist needs an update */
 242         if (c->playlist.version != mpd_status_get_queue_version(c->status)) {
 243                 c->events |= MPD_IDLE_PLAYLIST;
 244
 245                 if (!playlist_is_empty(&c->playlist))
 246                         retval = mpdclient_playlist_update_changes(c);
 247                 else
 248                         retval = mpdclient_playlist_update(c);
 249         } else
 250                 retval = true;
 251
 252         /* update the current song */
 253         if (!c->song || mpd_status_get_song_id(c->status)) {
 254                 c->song = playlist_get_song(&c->playlist,
 255                                             mpd_status_get_song_pos(c->status));
 256         }
 257
 258         return retval;
 259 }
 260
 261
 262 /****************************************************************************/
 263 /*** MPD Commands  **********************************************************/
 264 /****************************************************************************/
 265
 266 gint
 267 mpdclient_cmd_play(struct mpdclient *c, gint idx)
 268 {
 269         const struct mpd_song *song = playlist_get_song(&c->playlist, idx);
 270
 271         if (MPD_ERROR(c))
 272                 return -1;
 273
 274         if (song)
 275                 mpd_send_play_id(c->connection, mpd_song_get_id(song));
 276         else
 277                 mpd_send_play(c->connection);
 278
 279         return mpdclient_finish_command(c);
 280 }
 281
 282 gint
 283 mpdclient_cmd_crop(struct mpdclient *c)
 284 {
 285         struct mpd_status *status;
 286         bool playing;
 287         int length, current;
 288
 289         if (MPD_ERROR(c))
 290                 return -1;
 291
 292         status = mpd_run_status(c->connection);
 293         if (status == NULL)
 294                 return mpdclient_handle_error(c);
 295
 296         playing = mpd_status_get_state(status) == MPD_STATE_PLAY ||
 297                 mpd_status_get_state(status) == MPD_STATE_PAUSE;
 298         length = mpd_status_get_queue_length(status);
 299         current = mpd_status_get_song_pos(status);
 300
 301         mpd_status_free(status);
 302
 303         if (!playing || length < 2)
 304                 return 0;
 305
 306         mpd_command_list_begin(c->connection, false);
 307
 308         while (--length >= 0)
 309                 if (length != current)
 310                         mpd_send_delete(c->connection, length);
 311
 312         mpd_command_list_end(c->connection);
 313
 314         return mpdclient_finish_command(c);
 315 }
 316
 317 gint
 318 mpdclient_cmd_clear(struct mpdclient *c)
 319 {
 320         gint retval = 0;
 321
 322         if (MPD_ERROR(c))
 323                 return -1;
 324
 325         mpd_send_clear(c->connection);
 326         retval = mpdclient_finish_command(c);
 327
 328         if (retval)
 329                 c->events |= MPD_IDLE_PLAYLIST;
 330
 331         return retval;
 332 }
 333
 334 gint
 335 mpdclient_cmd_volume(struct mpdclient *c, gint value)
 336 {
 337         if (MPD_ERROR(c))
 338                 return -1;
 339
 340         mpd_send_set_volume(c->connection, value);
 341         return mpdclient_finish_command(c);
 342 }
 343
 344 gint mpdclient_cmd_volume_up(struct mpdclient *c)
 345 {
 346         if (MPD_ERROR(c))
 347                 return -1;
 348
 349         if (c->status == NULL ||
 350             mpd_status_get_volume(c->status) == -1)
 351                 return 0;
 352
 353         if (c->volume < 0)
 354                 c->volume = mpd_status_get_volume(c->status);
 355
 356         if (c->volume >= 100)
 357                 return 0;
 358
 359         return mpdclient_cmd_volume(c, ++c->volume);
 360 }
 361
 362 gint mpdclient_cmd_volume_down(struct mpdclient *c)
 363 {
 364         if (MPD_ERROR(c))
 365                 return -1;
 366
 367         if (c->status == NULL || mpd_status_get_volume(c->status) < 0)
 368                 return 0;
 369
 370         if (c->volume < 0)
 371                 c->volume = mpd_status_get_volume(c->status);
 372
 373         if (c->volume <= 0)
 374                 return 0;
 375
 376         return mpdclient_cmd_volume(c, --c->volume);
 377 }
 378
 379 gint
 380 mpdclient_cmd_add_path(struct mpdclient *c, const gchar *path_utf8)
 381 {
 382         if (MPD_ERROR(c))
 383                 return -1;
 384
 385         mpd_send_add(c->connection, path_utf8);
 386         return mpdclient_finish_command(c);
 387 }
 388
 389 gint
 390 mpdclient_cmd_add(struct mpdclient *c, const struct mpd_song *song)
 391 {
 392         struct mpd_status *status;
 393         struct mpd_song *new_song;
 394
 395         assert(c != NULL);
 396         assert(song != NULL);
 397
 398         if (MPD_ERROR(c) || c->status == NULL)
 399                 return -1;
 400
 401         /* send the add command to mpd; at the same time, get the new
 402            status (to verify the new playlist id) and the last song
 403            (we hope that's the song we just added) */
 404
 405         if (!mpd_command_list_begin(c->connection, true) ||
 406             !mpd_send_add(c->connection, mpd_song_get_uri(song)) ||
 407             !mpd_send_status(c->connection) ||
 408             !mpd_send_get_queue_song_pos(c->connection,
 409                                          playlist_length(&c->playlist)) ||
 410             !mpd_command_list_end(c->connection) ||
 411             !mpd_response_next(c->connection))
 412                 return mpdclient_handle_error(c);
 413
 414         c->events |= MPD_IDLE_PLAYLIST;
 415
 416         status = mpd_recv_status(c->connection);
 417         if (status != NULL) {
 418                 if (c->status != NULL)
 419                         mpd_status_free(c->status);
 420                 c->status = status;
 421         }
 422
 423         if (!mpd_response_next(c->connection))
 424                 return mpdclient_handle_error(c);
 425
 426         new_song = mpd_recv_song(c->connection);
 427         if (!mpd_response_finish(c->connection) || new_song == NULL) {
 428                 if (new_song != NULL)
 429                         mpd_song_free(new_song);
 430
 431                 return mpd_connection_clear_error(c->connection)
 432                         ? 0 : mpdclient_handle_error(c);
 433         }
 434
 435         if (mpd_status_get_queue_length(status) == playlist_length(&c->playlist) + 1 &&
 436             mpd_status_get_queue_version(status) == c->playlist.version + 1) {
 437                 /* the cheap route: match on the new playlist length
 438                    and its version, we can keep our local playlist
 439                    copy in sync */
 440                 c->playlist.version = mpd_status_get_queue_version(status);
 441
 442                 /* the song we just received has the correct id;
 443                    append it to the local playlist */
 444                 playlist_append(&c->playlist, new_song);
 445         }
 446
 447         mpd_song_free(new_song);
 448
 449         return -0;
 450 }
 451
 452 gint
 453 mpdclient_cmd_delete(struct mpdclient *c, gint idx)
 454 {
 455         const struct mpd_song *song;
 456         struct mpd_status *status;
 457
 458         if (MPD_ERROR(c) || c->status == NULL)
 459                 return -1;
 460
 461         if (idx < 0 || (guint)idx >= playlist_length(&c->playlist))
 462                 return -1;
 463
 464         song = playlist_get(&c->playlist, idx);
 465
 466         /* send the delete command to mpd; at the same time, get the
 467            new status (to verify the playlist id) */
 468
 469         if (!mpd_command_list_begin(c->connection, false) ||
 470             !mpd_send_delete_id(c->connection, mpd_song_get_id(song)) ||
 471             !mpd_send_status(c->connection) ||
 472             !mpd_command_list_end(c->connection))
 473                 return mpdclient_handle_error(c);
 474
 475         c->events |= MPD_IDLE_PLAYLIST;
 476
 477         status = mpd_recv_status(c->connection);
 478         if (status != NULL) {
 479                 if (c->status != NULL)
 480                         mpd_status_free(c->status);
 481                 c->status = status;
 482         }
 483
 484         if (!mpd_response_finish(c->connection))
 485                 return mpdclient_handle_error(c);
 486
 487         if (mpd_status_get_queue_length(status) == playlist_length(&c->playlist) - 1 &&
 488             mpd_status_get_queue_version(status) == c->playlist.version + 1) {
 489                 /* the cheap route: match on the new playlist length
 490                    and its version, we can keep our local playlist
 491                    copy in sync */
 492                 c->playlist.version = mpd_status_get_queue_version(status);
 493
 494                 /* remove the song from the local playlist */
 495                 playlist_remove(&c->playlist, idx);
 496
 497                 /* remove references to the song */
 498                 if (c->song == song)
 499                         c->song = NULL;
 500         }
 501
 502         return 0;
 503 }
 504
 505 /**
 506  * Fallback for mpdclient_cmd_delete_range() on MPD older than 0.16.
 507  * It emulates the "delete range" command with a list of simple
 508  * "delete" commands.
 509  */
 510 static gint
 511 mpdclient_cmd_delete_range_fallback(struct mpdclient *c,
 512                                     unsigned start, unsigned end)
 513 {
 514         if (!mpd_command_list_begin(c->connection, false))
 515                 return mpdclient_handle_error(c);
 516
 517         for (; start < end; --end)
 518                 mpd_send_delete(c->connection, start);
 519
 520         if (!mpd_command_list_end(c->connection) ||
 521             !mpd_response_finish(c->connection))
 522                 return mpdclient_handle_error(c);
 523
 524         return 0;
 525 }
 526
 527 gint
 528 mpdclient_cmd_delete_range(struct mpdclient *c, unsigned start, unsigned end)
 529 {
 530         struct mpd_status *status;
 531
 532         if (MPD_ERROR(c))
 533                 return -1;
 534
 535         if (mpd_connection_cmp_server_version(c->connection, 0, 16, 0) < 0)
 536                 return mpdclient_cmd_delete_range_fallback(c, start, end);
 537
 538         /* MPD 0.16 supports "delete" with a range argument */
 539
 540         /* send the delete command to mpd; at the same time, get the
 541            new status (to verify the playlist id) */
 542
 543         if (!mpd_command_list_begin(c->connection, false) ||
 544             !mpd_send_delete_range(c->connection, start, end) ||
 545             !mpd_send_status(c->connection) ||
 546             !mpd_command_list_end(c->connection))
 547                 return mpdclient_handle_error(c);
 548
 549         c->events |= MPD_IDLE_PLAYLIST;
 550
 551         status = mpd_recv_status(c->connection);
 552         if (status != NULL) {
 553                 if (c->status != NULL)
 554                         mpd_status_free(c->status);
 555                 c->status = status;
 556         }
 557
 558         if (!mpd_response_finish(c->connection))
 559                 return mpdclient_handle_error(c);
 560
 561         if (mpd_status_get_queue_length(status) == playlist_length(&c->playlist) - (end - start) &&
 562             mpd_status_get_queue_version(status) == c->playlist.version + 1) {
 563                 /* the cheap route: match on the new playlist length
 564                    and its version, we can keep our local playlist
 565                    copy in sync */
 566                 c->playlist.version = mpd_status_get_queue_version(status);
 567
 568                 /* remove the song from the local playlist */
 569                 while (end > start) {
 570                         --end;
 571
 572                         /* remove references to the song */
 573                         if (c->song == playlist_get(&c->playlist, end))
 574                                 c->song = NULL;
 575
 576                         playlist_remove(&c->playlist, end);
 577                 }
 578         }
 579
 580         return 0;
 581 }
 582
 583 gint
 584 mpdclient_cmd_move(struct mpdclient *c, gint old_index, gint new_index)
 585 {
 586         const struct mpd_song *song1, *song2;
 587         struct mpd_status *status;
 588
 589         if (MPD_ERROR(c))
 590                 return -1;
 591
 592         if (old_index == new_index || new_index < 0 ||
 593             (guint)new_index >= c->playlist.list->len)
 594                 return -1;
 595
 596         song1 = playlist_get(&c->playlist, old_index);
 597         song2 = playlist_get(&c->playlist, new_index);
 598
 599         /* send the delete command to mpd; at the same time, get the
 600            new status (to verify the playlist id) */
 601
 602         if (!mpd_command_list_begin(c->connection, false) ||
 603             !mpd_send_swap_id(c->connection, mpd_song_get_id(song1),
 604                               mpd_song_get_id(song2)) ||
 605             !mpd_send_status(c->connection) ||
 606             !mpd_command_list_end(c->connection))
 607                 return mpdclient_handle_error(c);
 608
 609         c->events |= MPD_IDLE_PLAYLIST;
 610
 611         status = mpd_recv_status(c->connection);
 612         if (status != NULL) {
 613                 if (c->status != NULL)
 614                         mpd_status_free(c->status);
 615                 c->status = status;
 616         }
 617
 618         if (!mpd_response_finish(c->connection))
 619                 return mpdclient_handle_error(c);
 620
 621         if (mpd_status_get_queue_length(status) == playlist_length(&c->playlist) &&
 622             mpd_status_get_queue_version(status) == c->playlist.version + 1) {
 623                 /* the cheap route: match on the new playlist length
 624                    and its version, we can keep our local playlist
 625                    copy in sync */
 626                 c->playlist.version = mpd_status_get_queue_version(status);
 627
 628                 /* swap songs in the local playlist */
 629                 playlist_swap(&c->playlist, old_index, new_index);
 630         }
 631
 632         return 0;
 633 }
 634
 635
 636 /****************************************************************************/
 637 /*** Playlist management functions ******************************************/
 638 /****************************************************************************/
 639
 640 /* update playlist */
 641 bool
 642 mpdclient_playlist_update(struct mpdclient *c)
 643 {
 644         struct mpd_entity *entity;
 645
 646         if (MPD_ERROR(c))
 647                 return false;
 648
 649         playlist_clear(&c->playlist);
 650
 651         mpd_send_list_queue_meta(c->connection);
 652         while ((entity = mpd_recv_entity(c->connection))) {
 653                 if (mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_SONG)
 654                         playlist_append(&c->playlist, mpd_entity_get_song(entity));
 655
 656                 mpd_entity_free(entity);
 657         }
 658
 659         c->playlist.version = mpd_status_get_queue_version(c->status);
 660         c->song = NULL;
 661
 662         return mpdclient_finish_command(c) == 0;
 663 }
 664
 665 /* update playlist (plchanges) */
 666 bool
 667 mpdclient_playlist_update_changes(struct mpdclient *c)
 668 {
 669         struct mpd_song *song;
 670         guint length;
 671
 672         if (MPD_ERROR(c))
 673                 return false;
 674
 675         mpd_send_queue_changes_meta(c->connection, c->playlist.version);
 676
 677         while ((song = mpd_recv_song(c->connection)) != NULL) {
 678                 int pos = mpd_song_get_pos(song);
 679
 680                 if (pos >= 0 && (guint)pos < c->playlist.list->len) {
 681                         /* update song */
 682                         playlist_replace(&c->playlist, pos, song);
 683                 } else {
 684                         /* add a new song */
 685                         playlist_append(&c->playlist, song);
 686                 }
 687
 688                 mpd_song_free(song);
 689         }
 690
 691         /* remove trailing songs */
 692
 693         length = mpd_status_get_queue_length(c->status);
 694         while (length < c->playlist.list->len) {
 695                 guint pos = c->playlist.list->len - 1;
 696
 697                 /* Remove the last playlist entry */
 698                 playlist_remove(&c->playlist, pos);
 699         }
 700
 701         c->song = NULL;
 702         c->playlist.version = mpd_status_get_queue_version(c->status);
 703
 704         return mpdclient_finish_command(c) == 0;
 705 }
 706
 707
 708 /****************************************************************************/
 709 /*** Filelist functions *****************************************************/
 710 /****************************************************************************/
 711
 712 struct filelist *
 713 mpdclient_filelist_get(struct mpdclient *c, const gchar *path)
 714 {
 715         struct filelist *filelist;
 716         struct mpd_entity *entity;
 717
 718         if (MPD_ERROR(c))
 719                 return NULL;
 720
 721         mpd_send_list_meta(c->connection, path);
 722         filelist = filelist_new();
 723
 724         while ((entity = mpd_recv_entity(c->connection)) != NULL)
 725                 filelist_append(filelist, entity);
 726
 727         if (mpdclient_finish_command(c)) {
 728                 filelist_free(filelist);
 729                 return NULL;
 730         }
 731
 732         filelist_sort_dir_play(filelist, compare_filelistentry);
 733
 734         return filelist;
 735 }
 736
 737 static struct filelist *
 738 mpdclient_recv_filelist_response(struct mpdclient *c)
 739 {
 740         struct filelist *filelist;
 741         struct mpd_entity *entity;
 742
 743         filelist = filelist_new();
 744
 745         while ((entity = mpd_recv_entity(c->connection)) != NULL)
 746                 filelist_append(filelist, entity);
 747
 748         if (mpdclient_finish_command(c)) {
 749                 filelist_free(filelist);
 750                 return NULL;
 751         }
 752
 753         return filelist;
 754 }
 755
 756 struct filelist *
 757 mpdclient_filelist_search(struct mpdclient *c,
 758                           int exact_match,
 759                           enum mpd_tag_type tag,
 760                           gchar *filter_utf8)
 761 {
 762         if (MPD_ERROR(c))
 763                 return NULL;
 764
 765         mpd_search_db_songs(c->connection, exact_match);
 766         mpd_search_add_tag_constraint(c->connection, MPD_OPERATOR_DEFAULT,
 767                                       tag, filter_utf8);
 768         mpd_search_commit(c->connection);
 769
 770         return mpdclient_recv_filelist_response(c);
 771 }
 772
 773 int
 774 mpdclient_filelist_add_all(struct mpdclient *c, struct filelist *fl)
 775 {
 776         guint i;
 777
 778         if (MPD_ERROR(c))
 779                 return -1;
 780
 781         if (filelist_is_empty(fl))
 782                 return 0;
 783
 784         mpd_command_list_begin(c->connection, false);
 785
 786         for (i = 0; i < filelist_length(fl); ++i) {
 787                 struct filelist_entry *entry = filelist_get(fl, i);
 788                 struct mpd_entity *entity  = entry->entity;
 789
 790                 if (entity != NULL &&
 791                     mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_SONG) {
 792                         const struct mpd_song *song =
 793                                 mpd_entity_get_song(entity);
 794                         const char *uri = mpd_song_get_uri(song);
 795
 796                         if (uri != NULL)
 797                                 mpd_send_add(c->connection, uri);
 798                 }
 799         }
 800
 801         mpd_command_list_end(c->connection);
 802         return mpdclient_finish_command(c);
 803 }
 804
 805 GList *
 806 mpdclient_get_artists(struct mpdclient *c)
 807 {
 808         GList *list = NULL;
 809         struct mpd_pair *pair;
 810
 811         if (MPD_ERROR(c))
 812                return NULL;
 813
 814         mpd_search_db_tags(c->connection, MPD_TAG_ARTIST);
 815         mpd_search_commit(c->connection);
 816
 817         while ((pair = mpd_recv_pair_tag(c->connection,
 818                                          MPD_TAG_ARTIST)) != NULL) {
 819                 list = g_list_append(list, g_strdup(pair->value));
 820                 mpd_return_pair(c->connection, pair);
 821         }
 822
 823         if (mpdclient_finish_command(c))
 824                 return string_list_free(list);
 825
 826         return list;
 827 }
 828
 829 GList *
 830 mpdclient_get_albums(struct mpdclient *c, const gchar *artist_utf8)
 831 {
 832         GList *list = NULL;
 833         struct mpd_pair *pair;
 834
 835         if (MPD_ERROR(c))
 836                return NULL;
 837
 838         mpd_search_db_tags(c->connection, MPD_TAG_ALBUM);
 839         if (artist_utf8 != NULL)
 840                 mpd_search_add_tag_constraint(c->connection,
 841                                               MPD_OPERATOR_DEFAULT,
 842                                               MPD_TAG_ARTIST, artist_utf8);
 843         mpd_search_commit(c->connection);
 844
 845         while ((pair = mpd_recv_pair_tag(c->connection,
 846                                          MPD_TAG_ALBUM)) != NULL) {
 847                 list = g_list_append(list, g_strdup(pair->value));
 848                 mpd_return_pair(c->connection, pair);
 849         }
 850
 851         if (mpdclient_finish_command(c))
 852                 return string_list_free(list);
 853
 854         return list;
 855 }