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