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