src/mpdclient.c

   1 /* ncmpc (Ncurses MPD Client)
   2  * (c) 2004-2017 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 "callbacks.h"
  22 #include "filelist.h"
  23 #include "config.h"
  24 #include "gidle.h"
  25 #include "charset.h"
  26
  27 #ifdef ENABLE_ASYNC_CONNECT
  28 #include "aconnect.h"
  29 #endif
  30
  31 #include <mpd/client.h>
  32
  33 #include <assert.h>
  34
  35 static gboolean
  36 mpdclient_enter_idle_callback(gpointer user_data)
  37 {
  38         struct mpdclient *c = user_data;
  39         assert(c->enter_idle_source_id != 0);
  40         assert(c->source != NULL);
  41         assert(!c->idle);
  42
  43         c->enter_idle_source_id = 0;
  44         c->idle = mpd_glib_enter(c->source);
  45         return false;
  46 }
  47
  48 static void
  49 mpdclient_schedule_enter_idle(struct mpdclient *c)
  50 {
  51         assert(c != NULL);
  52         assert(c->source != NULL);
  53
  54         if (c->enter_idle_source_id == 0)
  55                 /* automatically re-enter MPD "idle" mode */
  56                 c->enter_idle_source_id =
  57                         g_idle_add(mpdclient_enter_idle_callback, c);
  58 }
  59
  60 static void
  61 mpdclient_cancel_enter_idle(struct mpdclient *c)
  62 {
  63         if (c->enter_idle_source_id != 0) {
  64                 g_source_remove(c->enter_idle_source_id);
  65                 c->enter_idle_source_id = 0;
  66         }
  67 }
  68
  69 static void
  70 mpdclient_invoke_error_callback(enum mpd_error error,
  71                                 const char *message)
  72 {
  73         char *allocated;
  74         if (error == MPD_ERROR_SERVER)
  75                 /* server errors are UTF-8, the others are locale */
  76                 message = allocated = utf8_to_locale(message);
  77         else
  78                 allocated = NULL;
  79
  80         mpdclient_error_callback(message);
  81         g_free(allocated);
  82 }
  83
  84 static void
  85 mpdclient_invoke_error_callback1(struct mpdclient *c)
  86 {
  87         assert(c != NULL);
  88         assert(c->connection != NULL);
  89
  90         struct mpd_connection *connection = c->connection;
  91
  92         enum mpd_error error = mpd_connection_get_error(connection);
  93         assert(error != MPD_ERROR_SUCCESS);
  94
  95         mpdclient_invoke_error_callback(error,
  96                                         mpd_connection_get_error_message(connection));
  97 }
  98
  99 static void
 100 mpdclient_gidle_callback(enum mpd_error error,
 101                          gcc_unused enum mpd_server_error server_error,
 102                          const char *message, enum mpd_idle events,
 103                          void *ctx)
 104 {
 105         struct mpdclient *c = ctx;
 106
 107         c->idle = false;
 108
 109         assert(mpdclient_is_connected(c));
 110
 111         if (error != MPD_ERROR_SUCCESS) {
 112                 mpdclient_invoke_error_callback(error, message);
 113                 mpdclient_disconnect(c);
 114                 mpdclient_lost_callback();
 115                 return;
 116         }
 117
 118         c->events |= events;
 119         mpdclient_update(c);
 120
 121         mpdclient_idle_callback(c->events);
 122
 123         c->events = 0;
 124
 125         if (c->source != NULL)
 126                 mpdclient_schedule_enter_idle(c);
 127 }
 128
 129 /****************************************************************************/
 130 /*** mpdclient functions ****************************************************/
 131 /****************************************************************************/
 132
 133 bool
 134 mpdclient_handle_error(struct mpdclient *c)
 135 {
 136         enum mpd_error error = mpd_connection_get_error(c->connection);
 137
 138         assert(error != MPD_ERROR_SUCCESS);
 139
 140         if (error == MPD_ERROR_SERVER &&
 141             mpd_connection_get_server_error(c->connection) == MPD_SERVER_ERROR_PERMISSION &&
 142             mpdclient_auth_callback(c))
 143                 return true;
 144
 145         mpdclient_invoke_error_callback(error,
 146                                         mpd_connection_get_error_message(c->connection));
 147
 148         if (!mpd_connection_clear_error(c->connection)) {
 149                 mpdclient_disconnect(c);
 150                 mpdclient_lost_callback();
 151         }
 152
 153         return false;
 154 }
 155
 156 struct mpdclient *
 157 mpdclient_new(const gchar *host, unsigned port,
 158               unsigned timeout_ms, const gchar *password)
 159 {
 160         struct mpdclient *c = g_new0(struct mpdclient, 1);
 161
 162 #ifdef ENABLE_ASYNC_CONNECT
 163         c->settings = mpd_settings_new(host, port, timeout_ms,
 164                                        NULL, NULL);
 165         if (c->settings == NULL)
 166                 g_error("Out of memory");
 167 #else
 168         c->host = host;
 169         c->port = port;
 170 #endif
 171
 172         c->timeout_ms = timeout_ms;
 173         c->password = password;
 174
 175         playlist_init(&c->playlist);
 176         c->volume = -1;
 177         c->events = 0;
 178         c->playing = false;
 179
 180         return c;
 181 }
 182
 183 void
 184 mpdclient_free(struct mpdclient *c)
 185 {
 186         mpdclient_disconnect(c);
 187
 188         mpdclient_playlist_free(&c->playlist);
 189
 190 #ifdef ENABLE_ASYNC_CONNECT
 191         mpd_settings_free(c->settings);
 192 #endif
 193
 194         g_free(c);
 195 }
 196
 197 static char *
 198 settings_name(const struct mpd_settings *settings)
 199 {
 200         assert(settings != NULL);
 201
 202         const char *host = mpd_settings_get_host(settings);
 203         if (host == NULL)
 204                 host = "unknown";
 205
 206         if (host[0] == '/')
 207                 return g_strdup(host);
 208
 209         unsigned port = mpd_settings_get_port(settings);
 210         if (port == 0 || port == 6600)
 211                 return g_strdup(host);
 212
 213         return g_strdup_printf("%s:%u", host, port);
 214 }
 215
 216 char *
 217 mpdclient_settings_name(const struct mpdclient *c)
 218 {
 219         assert(c != NULL);
 220
 221 #ifdef ENABLE_ASYNC_CONNECT
 222         return settings_name(c->settings);
 223 #else
 224         struct mpd_settings *settings =
 225                 mpd_settings_new(c->host, c->port, 0, NULL, NULL);
 226         if (settings == NULL)
 227                 return g_strdup("unknown");
 228
 229         char *name = settings_name(settings);
 230         mpd_settings_free(settings);
 231         return name;
 232 #endif
 233 }
 234
 235 static void
 236 mpdclient_status_free(struct mpdclient *c)
 237 {
 238         if (c->status == NULL)
 239                 return;
 240
 241         mpd_status_free(c->status);
 242         c->status = NULL;
 243
 244         c->volume = -1;
 245         c->playing = false;
 246 }
 247
 248 void
 249 mpdclient_disconnect(struct mpdclient *c)
 250 {
 251 #ifdef ENABLE_ASYNC_CONNECT
 252         if (c->async_connect != NULL) {
 253                 aconnect_cancel(c->async_connect);
 254                 c->async_connect = NULL;
 255         }
 256 #endif
 257
 258         mpdclient_cancel_enter_idle(c);
 259
 260         if (c->source != NULL) {
 261                 mpd_glib_free(c->source);
 262                 c->source = NULL;
 263                 c->idle = false;
 264         }
 265
 266         if (c->connection) {
 267                 mpd_connection_free(c->connection);
 268                 ++c->connection_id;
 269         }
 270         c->connection = NULL;
 271
 272         mpdclient_status_free(c);
 273
 274         playlist_clear(&c->playlist);
 275
 276         if (c->song)
 277                 c->song = NULL;
 278
 279         /* everything has changed after a disconnect */
 280         c->events |= MPD_IDLE_ALL;
 281 }
 282
 283 static bool
 284 mpdclient_connected(struct mpdclient *c,
 285                     struct mpd_connection *connection)
 286 {
 287         c->connection = connection;
 288
 289         if (mpd_connection_get_error(connection) != MPD_ERROR_SUCCESS) {
 290                 mpdclient_invoke_error_callback1(c);
 291                 mpdclient_disconnect(c);
 292                 mpdclient_failed_callback();
 293                 return false;
 294         }
 295
 296 #ifdef ENABLE_ASYNC_CONNECT
 297         if (c->timeout_ms > 0)
 298                 mpd_connection_set_timeout(connection, c->timeout_ms);
 299 #endif
 300
 301         /* send password */
 302         if (c->password != NULL &&
 303             !mpd_run_password(connection, c->password)) {
 304                 mpdclient_invoke_error_callback1(c);
 305                 mpdclient_disconnect(c);
 306                 mpdclient_failed_callback();
 307                 return false;
 308         }
 309
 310         c->source = mpd_glib_new(connection,
 311                                  mpdclient_gidle_callback, c);
 312         mpdclient_schedule_enter_idle(c);
 313
 314         ++c->connection_id;
 315
 316         mpdclient_connected_callback();
 317         return true;
 318 }
 319
 320 #ifdef ENABLE_ASYNC_CONNECT
 321
 322 static void
 323 mpdclient_connect_success(struct mpd_connection *connection, void *ctx)
 324 {
 325         struct mpdclient *c = ctx;
 326         assert(c->async_connect != NULL);
 327         c->async_connect = NULL;
 328
 329         mpdclient_connected(c, connection);
 330 }
 331
 332 static void
 333 mpdclient_connect_error(const char *message, void *ctx)
 334 {
 335         struct mpdclient *c = ctx;
 336         assert(c->async_connect != NULL);
 337         c->async_connect = NULL;
 338
 339         mpdclient_error_callback(message);
 340         mpdclient_failed_callback();
 341 }
 342
 343 static const struct aconnect_handler mpdclient_connect_handler = {
 344         .success = mpdclient_connect_success,
 345         .error = mpdclient_connect_error,
 346 };
 347
 348 static void
 349 mpdclient_aconnect_start(struct mpdclient *c,
 350                          const struct mpd_settings *settings)
 351 {
 352         aconnect_start(&c->async_connect,
 353                        mpd_settings_get_host(settings),
 354                        mpd_settings_get_port(settings),
 355                        &mpdclient_connect_handler, c);
 356 }
 357
 358 #endif
 359
 360 void
 361 mpdclient_connect(struct mpdclient *c)
 362 {
 363         /* close any open connection */
 364         mpdclient_disconnect(c);
 365
 366 #ifdef ENABLE_ASYNC_CONNECT
 367         mpdclient_aconnect_start(c, c->settings);
 368 #else
 369         /* connect to MPD */
 370         struct mpd_connection *connection =
 371                 mpd_connection_new(c->host, c->port, c->timeout_ms);
 372         if (connection == NULL)
 373                 g_error("Out of memory");
 374
 375         mpdclient_connected(c, connection);
 376 #endif
 377 }
 378
 379 bool
 380 mpdclient_update(struct mpdclient *c)
 381 {
 382         struct mpd_connection *connection = mpdclient_get_connection(c);
 383
 384         if (connection == NULL)
 385                 return false;
 386
 387         /* free the old status */
 388         mpdclient_status_free(c);
 389
 390         /* retrieve new status */
 391         c->status = mpd_run_status(connection);
 392         if (c->status == NULL)
 393                 return mpdclient_handle_error(c);
 394
 395         c->volume = mpd_status_get_volume(c->status);
 396         c->playing = mpd_status_get_state(c->status) == MPD_STATE_PLAY;
 397
 398         /* check if the playlist needs an update */
 399         if (c->playlist.version != mpd_status_get_queue_version(c->status)) {
 400                 bool retval;
 401
 402                 if (!playlist_is_empty(&c->playlist))
 403                         retval = mpdclient_playlist_update_changes(c);
 404                 else
 405                         retval = mpdclient_playlist_update(c);
 406                 if (!retval)
 407                         return false;
 408         }
 409
 410         /* update the current song */
 411         if (!c->song || mpd_status_get_song_id(c->status) >= 0) {
 412                 c->song = playlist_get_song(&c->playlist,
 413                                             mpd_status_get_song_pos(c->status));
 414         }
 415
 416         return true;
 417 }
 418
 419 struct mpd_connection *
 420 mpdclient_get_connection(struct mpdclient *c)
 421 {
 422         if (c->source != NULL && c->idle) {
 423                 c->idle = false;
 424                 mpd_glib_leave(c->source);
 425
 426                 mpdclient_schedule_enter_idle(c);
 427         }
 428
 429         return c->connection;
 430 }
 431
 432 static struct mpd_status *
 433 mpdclient_recv_status(struct mpdclient *c)
 434 {
 435         assert(c->connection != NULL);
 436
 437         struct mpd_status *status = mpd_recv_status(c->connection);
 438         if (status == NULL) {
 439                 mpdclient_handle_error(c);
 440                 return NULL;
 441         }
 442
 443         if (c->status != NULL)
 444                 mpd_status_free(c->status);
 445         return c->status = status;
 446 }
 447
 448 /****************************************************************************/
 449 /*** MPD Commands  **********************************************************/
 450 /****************************************************************************/
 451
 452 bool
 453 mpdclient_cmd_crop(struct mpdclient *c)
 454 {
 455         if (!mpdclient_is_playing(c))
 456                 return false;
 457
 458         int length = mpd_status_get_queue_length(c->status);
 459         int current = mpd_status_get_song_pos(c->status);
 460         if (current < 0 || mpd_status_get_queue_length(c->status) < 2)
 461                 return true;
 462
 463         struct mpd_connection *connection = mpdclient_get_connection(c);
 464         if (connection == NULL)
 465                 return false;
 466
 467         mpd_command_list_begin(connection, false);
 468
 469         if (current < length - 1)
 470                 mpd_send_delete_range(connection, current + 1, length);
 471         if (current > 0)
 472                 mpd_send_delete_range(connection, 0, current);
 473
 474         mpd_command_list_end(connection);
 475
 476         return mpdclient_finish_command(c);
 477 }
 478
 479 bool
 480 mpdclient_cmd_clear(struct mpdclient *c)
 481 {
 482         struct mpd_connection *connection = mpdclient_get_connection(c);
 483         if (connection == NULL)
 484                 return false;
 485
 486         /* send "clear" and "status" */
 487         if (!mpd_command_list_begin(connection, false) ||
 488             !mpd_send_clear(connection) ||
 489             !mpd_send_status(connection) ||
 490             !mpd_command_list_end(connection))
 491                 return mpdclient_handle_error(c);
 492
 493         /* receive the new status, store it in the mpdclient struct */
 494
 495         struct mpd_status *status = mpdclient_recv_status(c);
 496         if (status == NULL)
 497                 return false;
 498
 499         if (!mpd_response_finish(connection))
 500                 return mpdclient_handle_error(c);
 501
 502         /* update mpdclient.playlist */
 503
 504         if (mpd_status_get_queue_length(status) == 0) {
 505                 /* after the "clear" command, the queue is really
 506                    empty - this means we can clear it locally,
 507                    reducing the UI latency */
 508                 playlist_clear(&c->playlist);
 509                 c->playlist.version = mpd_status_get_queue_version(status);
 510                 c->song = NULL;
 511         }
 512
 513         c->events |= MPD_IDLE_QUEUE;
 514         return true;
 515 }
 516
 517 bool
 518 mpdclient_cmd_volume(struct mpdclient *c, gint value)
 519 {
 520         struct mpd_connection *connection = mpdclient_get_connection(c);
 521         if (connection == NULL)
 522                 return false;
 523
 524         mpd_send_set_volume(connection, value);
 525         return mpdclient_finish_command(c);
 526 }
 527
 528 bool
 529 mpdclient_cmd_volume_up(struct mpdclient *c)
 530 {
 531         if (c->volume < 0 || c->volume >= 100)
 532                 return true;
 533
 534         struct mpd_connection *connection = mpdclient_get_connection(c);
 535         if (connection == NULL)
 536                 return false;
 537
 538         return mpdclient_cmd_volume(c, ++c->volume);
 539 }
 540
 541 bool
 542 mpdclient_cmd_volume_down(struct mpdclient *c)
 543 {
 544         if (c->volume <= 0)
 545                 return true;
 546
 547         struct mpd_connection *connection = mpdclient_get_connection(c);
 548         if (connection == NULL)
 549                 return false;
 550
 551         return mpdclient_cmd_volume(c, --c->volume);
 552 }
 553
 554 bool
 555 mpdclient_cmd_add_path(struct mpdclient *c, const gchar *path_utf8)
 556 {
 557         struct mpd_connection *connection = mpdclient_get_connection(c);
 558         if (connection == NULL)
 559                 return false;
 560
 561         return mpd_send_add(connection, path_utf8)?
 562                 mpdclient_finish_command(c) : false;
 563 }
 564
 565 bool
 566 mpdclient_cmd_add(struct mpdclient *c, const struct mpd_song *song)
 567 {
 568         assert(c != NULL);
 569         assert(song != NULL);
 570
 571         struct mpd_connection *connection = mpdclient_get_connection(c);
 572         if (connection == NULL || c->status == NULL)
 573                 return false;
 574
 575         /* send the add command to mpd; at the same time, get the new
 576            status (to verify the new playlist id) and the last song
 577            (we hope that's the song we just added) */
 578
 579         if (!mpd_command_list_begin(connection, true) ||
 580             !mpd_send_add(connection, mpd_song_get_uri(song)) ||
 581             !mpd_send_status(connection) ||
 582             !mpd_send_get_queue_song_pos(connection,
 583                                          playlist_length(&c->playlist)) ||
 584             !mpd_command_list_end(connection) ||
 585             !mpd_response_next(connection))
 586                 return mpdclient_handle_error(c);
 587
 588         c->events |= MPD_IDLE_QUEUE;
 589
 590         struct mpd_status *status = mpdclient_recv_status(c);
 591         if (status == NULL)
 592                 return false;
 593
 594         if (!mpd_response_next(connection))
 595                 return mpdclient_handle_error(c);
 596
 597         struct mpd_song *new_song = mpd_recv_song(connection);
 598         if (!mpd_response_finish(connection) || new_song == NULL) {
 599                 if (new_song != NULL)
 600                         mpd_song_free(new_song);
 601
 602                 return mpd_connection_clear_error(connection) ||
 603                         mpdclient_handle_error(c);
 604         }
 605
 606         if (mpd_status_get_queue_length(status) == playlist_length(&c->playlist) + 1 &&
 607             mpd_status_get_queue_version(status) == c->playlist.version + 1) {
 608                 /* the cheap route: match on the new playlist length
 609                    and its version, we can keep our local playlist
 610                    copy in sync */
 611                 c->playlist.version = mpd_status_get_queue_version(status);
 612
 613                 /* the song we just received has the correct id;
 614                    append it to the local playlist */
 615                 playlist_append(&c->playlist, new_song);
 616         }
 617
 618         mpd_song_free(new_song);
 619
 620         return true;
 621 }
 622
 623 bool
 624 mpdclient_cmd_delete(struct mpdclient *c, gint idx)
 625 {
 626         struct mpd_connection *connection = mpdclient_get_connection(c);
 627
 628         if (connection == NULL || c->status == NULL)
 629                 return false;
 630
 631         if (idx < 0 || (guint)idx >= playlist_length(&c->playlist))
 632                 return false;
 633
 634         const struct mpd_song *song = playlist_get(&c->playlist, idx);
 635
 636         /* send the delete command to mpd; at the same time, get the
 637            new status (to verify the playlist id) */
 638
 639         if (!mpd_command_list_begin(connection, false) ||
 640             !mpd_send_delete_id(connection, mpd_song_get_id(song)) ||
 641             !mpd_send_status(connection) ||
 642             !mpd_command_list_end(connection))
 643                 return mpdclient_handle_error(c);
 644
 645         c->events |= MPD_IDLE_QUEUE;
 646
 647         struct mpd_status *status = mpdclient_recv_status(c);
 648         if (status == NULL)
 649                 return false;
 650
 651         if (!mpd_response_finish(connection))
 652                 return mpdclient_handle_error(c);
 653
 654         if (mpd_status_get_queue_length(status) == playlist_length(&c->playlist) - 1 &&
 655             mpd_status_get_queue_version(status) == c->playlist.version + 1) {
 656                 /* the cheap route: match on the new playlist length
 657                    and its version, we can keep our local playlist
 658                    copy in sync */
 659                 c->playlist.version = mpd_status_get_queue_version(status);
 660
 661                 /* remove the song from the local playlist */
 662                 playlist_remove(&c->playlist, idx);
 663
 664                 /* remove references to the song */
 665                 if (c->song == song)
 666                         c->song = NULL;
 667         }
 668
 669         return true;
 670 }
 671
 672 bool
 673 mpdclient_cmd_delete_range(struct mpdclient *c, unsigned start, unsigned end)
 674 {
 675         if (end == start + 1)
 676                 /* if that's not really a range, we choose to use the
 677                    safer "deleteid" version */
 678                 return mpdclient_cmd_delete(c, start);
 679
 680         struct mpd_connection *connection = mpdclient_get_connection(c);
 681         if (connection == NULL)
 682                 return false;
 683
 684         /* send the delete 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_delete_range(connection, start, end) ||
 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         struct mpd_status *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) - (end - start) &&
 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                 /* remove the song from the local playlist */
 710                 while (end > start) {
 711                         --end;
 712
 713                         /* remove references to the song */
 714                         if (c->song == playlist_get(&c->playlist, end))
 715                                 c->song = NULL;
 716
 717                         playlist_remove(&c->playlist, end);
 718                 }
 719         }
 720
 721         return true;
 722 }
 723
 724 bool
 725 mpdclient_cmd_move(struct mpdclient *c, unsigned dest_pos, unsigned src_pos)
 726 {
 727         if (dest_pos == src_pos)
 728                 return true;
 729
 730         struct mpd_connection *connection = mpdclient_get_connection(c);
 731         if (connection == NULL)
 732                 return false;
 733
 734         /* send the "move" command to MPD; at the same time, get the
 735            new status (to verify the playlist id) */
 736
 737         if (!mpd_command_list_begin(connection, false) ||
 738             !mpd_send_move(connection, src_pos, dest_pos) ||
 739             !mpd_send_status(connection) ||
 740             !mpd_command_list_end(connection))
 741                 return mpdclient_handle_error(c);
 742
 743         c->events |= MPD_IDLE_QUEUE;
 744
 745         struct mpd_status *status = mpdclient_recv_status(c);
 746         if (status == NULL)
 747                 return false;
 748
 749         if (!mpd_response_finish(connection))
 750                 return mpdclient_handle_error(c);
 751
 752         if (mpd_status_get_queue_length(status) == playlist_length(&c->playlist) &&
 753             mpd_status_get_queue_version(status) == c->playlist.version + 1) {
 754                 /* the cheap route: match on the new playlist length
 755                    and its version, we can keep our local playlist
 756                    copy in sync */
 757                 c->playlist.version = mpd_status_get_queue_version(status);
 758
 759                 /* swap songs in the local playlist */
 760                 playlist_move(&c->playlist, dest_pos, src_pos);
 761         }
 762
 763         return true;
 764 }
 765
 766 /* The client-to-client protocol (MPD 0.17.0) */
 767
 768 bool
 769 mpdclient_cmd_subscribe(struct mpdclient *c, const char *channel)
 770 {
 771         struct mpd_connection *connection = mpdclient_get_connection(c);
 772
 773         if (connection == NULL)
 774                 return false;
 775
 776         if (!mpd_send_subscribe(connection, channel))
 777                 return mpdclient_handle_error(c);
 778
 779         return mpdclient_finish_command(c);
 780 }
 781
 782 bool
 783 mpdclient_cmd_unsubscribe(struct mpdclient *c, const char *channel)
 784 {
 785         struct mpd_connection *connection = mpdclient_get_connection(c);
 786         if (connection == NULL)
 787                 return false;
 788
 789         if (!mpd_send_unsubscribe(connection, channel))
 790                 return mpdclient_handle_error(c);
 791
 792         return mpdclient_finish_command(c);
 793 }
 794
 795 bool
 796 mpdclient_cmd_send_message(struct mpdclient *c, const char *channel,
 797                            const char *text)
 798 {
 799         struct mpd_connection *connection = mpdclient_get_connection(c);
 800         if (connection == NULL)
 801                 return false;
 802
 803         if (!mpd_send_send_message(connection, channel, text))
 804                 return mpdclient_handle_error(c);
 805
 806         return mpdclient_finish_command(c);
 807 }
 808
 809 bool
 810 mpdclient_send_read_messages(struct mpdclient *c)
 811 {
 812         struct mpd_connection *connection = mpdclient_get_connection(c);
 813         if (connection == NULL)
 814                 return false;
 815
 816         return mpd_send_read_messages(connection)?
 817                 true : mpdclient_handle_error(c);
 818 }
 819
 820 struct mpd_message *
 821 mpdclient_recv_message(struct mpdclient *c)
 822 {
 823         struct mpd_connection *connection = mpdclient_get_connection(c);
 824         if (connection == NULL)
 825                 return false;
 826
 827         struct mpd_message *message = mpd_recv_message(connection);
 828         if (message == NULL &&
 829             mpd_connection_get_error(connection) != MPD_ERROR_SUCCESS)
 830                 mpdclient_handle_error(c);
 831
 832         return message;
 833 }
 834
 835 /****************************************************************************/
 836 /*** Playlist management functions ******************************************/
 837 /****************************************************************************/
 838
 839 /* update playlist */
 840 bool
 841 mpdclient_playlist_update(struct mpdclient *c)
 842 {
 843         struct mpd_connection *connection = mpdclient_get_connection(c);
 844         if (connection == NULL)
 845                 return false;
 846
 847         playlist_clear(&c->playlist);
 848
 849         mpd_send_list_queue_meta(connection);
 850
 851         struct mpd_entity *entity;
 852         while ((entity = mpd_recv_entity(connection))) {
 853                 if (mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_SONG)
 854                         playlist_append(&c->playlist, mpd_entity_get_song(entity));
 855
 856                 mpd_entity_free(entity);
 857         }
 858
 859         c->playlist.version = mpd_status_get_queue_version(c->status);
 860         c->song = NULL;
 861
 862         return mpdclient_finish_command(c);
 863 }
 864
 865 /* update playlist (plchanges) */
 866 bool
 867 mpdclient_playlist_update_changes(struct mpdclient *c)
 868 {
 869         struct mpd_connection *connection = mpdclient_get_connection(c);
 870
 871         if (connection == NULL)
 872                 return false;
 873
 874         mpd_send_queue_changes_meta(connection, c->playlist.version);
 875
 876         struct mpd_song *song;
 877         while ((song = mpd_recv_song(connection)) != NULL) {
 878                 int pos = mpd_song_get_pos(song);
 879
 880                 if (pos >= 0 && (guint)pos < c->playlist.list->len) {
 881                         /* update song */
 882                         playlist_replace(&c->playlist, pos, song);
 883                 } else {
 884                         /* add a new song */
 885                         playlist_append(&c->playlist, song);
 886                 }
 887
 888                 mpd_song_free(song);
 889         }
 890
 891         /* remove trailing songs */
 892
 893         unsigned length = mpd_status_get_queue_length(c->status);
 894         while (length < c->playlist.list->len) {
 895                 guint pos = c->playlist.list->len - 1;
 896
 897                 /* Remove the last playlist entry */
 898                 playlist_remove(&c->playlist, pos);
 899         }
 900
 901         c->song = NULL;
 902         c->playlist.version = mpd_status_get_queue_version(c->status);
 903
 904         return mpdclient_finish_command(c);
 905 }
 906
 907
 908 /****************************************************************************/
 909 /*** Filelist functions *****************************************************/
 910 /****************************************************************************/
 911
 912 bool
 913 mpdclient_filelist_add_all(struct mpdclient *c, struct filelist *fl)
 914 {
 915         struct mpd_connection *connection = mpdclient_get_connection(c);
 916         if (connection == NULL)
 917                 return false;
 918
 919         if (filelist_is_empty(fl))
 920                 return true;
 921
 922         mpd_command_list_begin(connection, false);
 923
 924         for (unsigned i = 0; i < filelist_length(fl); ++i) {
 925                 struct filelist_entry *entry = filelist_get(fl, i);
 926                 struct mpd_entity *entity  = entry->entity;
 927
 928                 if (entity != NULL &&
 929                     mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_SONG) {
 930                         const struct mpd_song *song =
 931                                 mpd_entity_get_song(entity);
 932
 933                         mpd_send_add(connection, mpd_song_get_uri(song));
 934                 }
 935         }
 936
 937         mpd_command_list_end(connection);
 938         return mpdclient_finish_command(c);
 939 }