src/mpdclient.c

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