daapsharing/rb-daap-connection.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
   2  *
   3  *  Implementation of DAAP (iTunes Music Sharing) hashing, parsing, connection
   4  *
   5  *  Copyright (C) 2004-2005 Charles Schmidt <cschmidt2@emich.edu>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.
  20  *
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <sys/types.h>
  28 #include <math.h>
  29 #ifdef HAVE_LIBZ
  30 #include <zlib.h>
  31 #endif
  32
  33 #include <glib/gi18n.h>
  34 #include <gdk/gdk.h>
  35
  36 #include <libsoup/soup.h>
  37 #include <libsoup/soup-connection.h>
  38 #include <libsoup/soup-session-sync.h>
  39 #include <libsoup/soup-uri.h>
  40
  41 #include "rb-daap-hash.h"
  42 #include "rb-daap-connection.h"
  43 #include "rb-daap-structure.h"
  44 #include "rb-marshal.h"
  45
  46 #include "rb-debug.h"
  47 #include "rb-util.h"
  48
  49 #define RB_DAAP_USER_AGENT "iTunes/4.6 (Windows; N)"
  50
  51 static void      rb_daap_connection_dispose      (GObject *obj);
  52 static void      rb_daap_connection_set_property (GObject *object,
  53                                                   guint prop_id,
  54                                                   const GValue *value,
  55                                                   GParamSpec *pspec);
  56 static void      rb_daap_connection_get_property (GObject *object,
  57                                                   guint prop_id,
  58                                                   GValue *value,
  59                                                   GParamSpec *pspec);
  60
  61 static gboolean rb_daap_connection_do_something  (RBDAAPConnection *connection);
  62 static void     rb_daap_connection_state_done    (RBDAAPConnection *connection,
  63                                                   gboolean           result);
  64
  65 static gboolean emit_progress_idle (RBDAAPConnection *connection);
  66
  67 G_DEFINE_TYPE (RBDAAPConnection, rb_daap_connection, G_TYPE_OBJECT)
  68
  69 #define RB_DAAP_CONNECTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), RB_TYPE_DAAP_CONNECTION, RBDAAPConnectionPrivate))
  70
  71 typedef void (* RBDAAPResponseHandler) (RBDAAPConnection *connection,
  72                                         guint status,
  73                                         GNode *structure);
  74
  75 struct RBDAAPConnectionPrivate {
  76         char *name;
  77         gboolean password_protected;
  78         char *username;
  79         char *password;
  80         char *host;
  81         guint port;
  82
  83         gboolean is_connected;
  84         gboolean is_connecting;
  85
  86         SoupSession *session;
  87         SoupUri *base_uri;
  88         gchar *daap_base_uri;
  89
  90         gdouble daap_version;
  91         guint32 session_id;
  92         gint revision_number;
  93
  94         gint request_id;
  95         gint database_id;
  96
  97         guint reading_playlist;
  98         GSList *playlists;
  99         GHashTable *item_id_to_uri;
 100
 101         RhythmDB *db;
 102         RhythmDBEntryType db_type;
 103
 104         RBDAAPConnectionState state;
 105         RBDAAPResponseHandler response_handler;
 106         gboolean use_response_handler_thread;
 107         float progress;
 108
 109         guint emit_progress_id;
 110         guint do_something_id;
 111
 112         gboolean result;
 113         char *last_error_message;
 114 };
 115
 116 enum {
 117         PROP_0,
 118         PROP_DB,
 119         PROP_NAME,
 120         PROP_ENTRY_TYPE,
 121         PROP_PASSWORD_PROTECTED,
 122         PROP_HOST,
 123         PROP_PORT,
 124 };
 125
 126 enum {
 127         AUTHENTICATE,
 128         CONNECTING,
 129         CONNECTED,
 130         DISCONNECTED,
 131         OPERATION_DONE,
 132         LAST_SIGNAL
 133 };
 134
 135 static guint signals [LAST_SIGNAL] = { 0, };
 136
 137 static void
 138 rb_daap_connection_finalize (GObject *object)
 139 {
 140         RBDAAPConnection *connection;
 141
 142         g_return_if_fail (object != NULL);
 143         g_return_if_fail (RB_IS_DAAP_CONNECTION (object));
 144
 145         connection = RB_DAAP_CONNECTION (object);
 146
 147         g_return_if_fail (connection->priv != NULL);
 148
 149         rb_debug ("Finalize");
 150
 151         G_OBJECT_CLASS (rb_daap_connection_parent_class)->finalize (object);
 152 }
 153
 154 static void
 155 rb_daap_connection_class_init (RBDAAPConnectionClass *klass)
 156 {
 157         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 158
 159         object_class->finalize     = rb_daap_connection_finalize;
 160         object_class->dispose       = rb_daap_connection_dispose;
 161         object_class->set_property = rb_daap_connection_set_property;
 162         object_class->get_property = rb_daap_connection_get_property;
 163
 164         g_type_class_add_private (klass, sizeof (RBDAAPConnectionPrivate));
 165
 166         g_object_class_install_property (object_class,
 167                                          PROP_DB,
 168                                          g_param_spec_object ("db",
 169                                                               "RhythmDB",
 170                                                               "RhythmDB object",
 171                                                               RHYTHMDB_TYPE,
 172                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 173         g_object_class_install_property (object_class,
 174                                          PROP_ENTRY_TYPE,
 175                                          g_param_spec_boxed ("entry-type",
 176                                                              "entry type",
 177                                                              "RhythmDBEntryType",
 178                                                              RHYTHMDB_TYPE_ENTRY_TYPE,
 179                                                              G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 180
 181         g_object_class_install_property (object_class,
 182                                          PROP_PASSWORD_PROTECTED,
 183                                          g_param_spec_boolean ("password-protected",
 184                                                                "password protected",
 185                                                                "connection is password protected",
 186                                                                FALSE,
 187                                                                G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 188         g_object_class_install_property (object_class,
 189                                          PROP_NAME,
 190                                          g_param_spec_string ("name",
 191                                                               "connection name",
 192                                                               "connection name",
 193                                                               NULL,
 194                                                                G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 195         g_object_class_install_property (object_class,
 196                                          PROP_HOST,
 197                                          g_param_spec_string ("host",
 198                                                               "host",
 199                                                               "host",
 200                                                               NULL,
 201                                                                G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 202         g_object_class_install_property (object_class,
 203                                          PROP_PORT,
 204                                          g_param_spec_uint ("port",
 205                                                             "port",
 206                                                             "port",
 207                                                             0, G_MAXINT, 0,
 208                                                             G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 209
 210         signals [AUTHENTICATE] = g_signal_new ("authenticate",
 211                                                G_TYPE_FROM_CLASS (object_class),
 212                                                G_SIGNAL_RUN_LAST,
 213                                                G_STRUCT_OFFSET (RBDAAPConnectionClass, authenticate),
 214                                                NULL,
 215                                                NULL,
 216                                                rb_marshal_STRING__STRING,
 217                                                G_TYPE_STRING,
 218                                                1, G_TYPE_STRING);
 219         signals [CONNECTING] = g_signal_new ("connecting",
 220                                              G_TYPE_FROM_CLASS (object_class),
 221                                              G_SIGNAL_RUN_LAST,
 222                                              G_STRUCT_OFFSET (RBDAAPConnectionClass, connecting),
 223                                              NULL,
 224                                              NULL,
 225                                              rb_marshal_VOID__ULONG_FLOAT,
 226                                              G_TYPE_NONE,
 227                                              2, G_TYPE_ULONG, G_TYPE_FLOAT);
 228         signals [CONNECTED] = g_signal_new ("connected",
 229                                             G_TYPE_FROM_CLASS (object_class),
 230                                             G_SIGNAL_RUN_LAST,
 231                                             G_STRUCT_OFFSET (RBDAAPConnectionClass, connected),
 232                                             NULL,
 233                                             NULL,
 234                                             g_cclosure_marshal_VOID__VOID,
 235                                                G_TYPE_NONE,
 236                                             0);
 237         signals [DISCONNECTED] = g_signal_new ("disconnected",
 238                                                G_TYPE_FROM_CLASS (object_class),
 239                                                G_SIGNAL_RUN_LAST,
 240                                                G_STRUCT_OFFSET (RBDAAPConnectionClass, disconnected),
 241                                                NULL,
 242                                                NULL,
 243                                                g_cclosure_marshal_VOID__VOID,
 244                                                G_TYPE_NONE,
 245                                                0);
 246         signals [OPERATION_DONE] = g_signal_new ("operation-done",
 247                                                  G_TYPE_FROM_CLASS (object_class),
 248                                                  G_SIGNAL_RUN_FIRST,
 249                                                  G_STRUCT_OFFSET (RBDAAPConnectionClass, operation_done),
 250                                                  NULL,
 251                                                  NULL,
 252                                                  g_cclosure_marshal_VOID__VOID,
 253                                                  G_TYPE_NONE,
 254                                                  0);
 255 }
 256
 257 static void
 258 rb_daap_connection_init (RBDAAPConnection *connection)
 259 {
 260         connection->priv = RB_DAAP_CONNECTION_GET_PRIVATE (connection);
 261
 262         connection->priv->username = g_strdup_printf ("Rhythmbox_%s", VERSION);
 263         connection->priv->db_type = RHYTHMDB_ENTRY_TYPE_INVALID;
 264 }
 265
 266 static char *
 267 connection_get_password (RBDAAPConnection *connection)
 268 {
 269         char *password = NULL;;
 270
 271         GDK_THREADS_ENTER ();
 272         g_signal_emit (connection,
 273                        signals [AUTHENTICATE],
 274                        0,
 275                        connection->priv->name,
 276                        &password);
 277         GDK_THREADS_LEAVE ();
 278
 279         return password;
 280 }
 281
 282 static void
 283 connection_connected (RBDAAPConnection *connection)
 284 {
 285         rb_debug ("Emitting connected");
 286
 287         connection->priv->is_connected = TRUE;
 288
 289         GDK_THREADS_ENTER ();
 290         g_signal_emit (connection,
 291                        signals [CONNECTED],
 292                        0);
 293         GDK_THREADS_LEAVE ();
 294 }
 295
 296 static void
 297 connection_disconnected (RBDAAPConnection *connection)
 298 {
 299         rb_debug ("Emitting disconnected");
 300
 301         connection->priv->is_connected = FALSE;
 302
 303         GDK_THREADS_ENTER ();
 304         g_signal_emit (connection,
 305                        signals [DISCONNECTED],
 306                        0);
 307         GDK_THREADS_LEAVE ();
 308 }
 309
 310 static void
 311 connection_operation_done (RBDAAPConnection *connection)
 312 {
 313         rb_debug ("Emitting operation done");
 314
 315         GDK_THREADS_ENTER ();
 316         g_signal_emit (connection,
 317                        signals [OPERATION_DONE],
 318                        0);
 319         GDK_THREADS_LEAVE ();
 320 }
 321
 322 static SoupMessage *
 323 build_message (RBDAAPConnection *connection,
 324                const char       *path,
 325                gboolean          need_hash,
 326                gdouble           version,
 327                gint              req_id,
 328                gboolean          send_close)
 329 {
 330         RBDAAPConnectionPrivate *priv = connection->priv;
 331         SoupMessage *message = NULL;
 332         SoupUri *uri = NULL;
 333
 334         uri = soup_uri_new_with_base (priv->base_uri, path);
 335         if (uri == NULL) {
 336                 return NULL;
 337         }
 338
 339         message = soup_message_new_from_uri (SOUP_METHOD_GET, uri);
 340         soup_message_set_http_version (message, SOUP_HTTP_1_1);
 341
 342         soup_message_add_header (message->request_headers, "Client-DAAP-Version",       "3.0");
 343         soup_message_add_header (message->request_headers, "Accept-Language",           "en-us, en;q=5.0");
 344 #ifdef HAVE_LIBZ
 345         soup_message_add_header (message->request_headers, "Accept-Encoding",           "gzip");
 346 #endif
 347         soup_message_add_header (message->request_headers, "Client-DAAP-Access-Index",  "2");
 348
 349         if (priv->password_protected) {
 350                 char *h;
 351                 char *user_pass;
 352                 char *token;
 353
 354                 user_pass = g_strdup_printf ("%s:%s", priv->username, priv->password);
 355                 token = soup_base64_encode (user_pass, strlen (user_pass));
 356                 h = g_strdup_printf ("Basic %s", token);
 357
 358                 g_free (token);
 359                 g_free (user_pass);
 360
 361                 soup_message_add_header (message->request_headers, "Authorization", h);
 362                 g_free (h);
 363         }
 364
 365         if (need_hash) {
 366                 gchar hash[33] = {0};
 367                 gchar *no_daap_path = (gchar *)path;
 368
 369                 if (g_strncasecmp (path, "daap://", 7) == 0) {
 370                         no_daap_path = strstr (path, "/data");
 371                 }
 372
 373                 rb_daap_hash_generate ((short)floor (version), (const guchar*)no_daap_path, 2, (guchar*)hash, req_id);
 374
 375                 soup_message_add_header (message->request_headers, "Client-DAAP-Validation", hash);
 376         }
 377         if (send_close) {
 378                 soup_message_add_header (message->request_headers, "Connection", "close");
 379         }
 380
 381         soup_uri_free (uri);
 382
 383         return message;
 384 }
 385
 386 #ifdef HAVE_LIBZ
 387 static void
 388 *g_zalloc_wrapper (voidpf opaque, uInt items, uInt size)
 389 {
 390         if ((items != 0) && (size >= G_MAXUINT/items)) {
 391                 return Z_NULL;
 392         }
 393         if ((size != 0) && (items >= G_MAXUINT/size)) {
 394                 return Z_NULL;
 395         }
 396         return g_malloc0 (items * size);
 397 }
 398
 399 static void
 400 g_zfree_wrapper (voidpf opaque, voidpf address)
 401 {
 402         g_free (address);
 403 }
 404 #endif
 405
 406 static void
 407 connection_set_error_message (RBDAAPConnection *connection,
 408                               const char       *message)
 409 {
 410         /* FIXME: obtain a lock */
 411         if (connection->priv->last_error_message != NULL) {
 412                 g_free (connection->priv->last_error_message);
 413         }
 414         connection->priv->last_error_message = g_strdup (message);
 415 }
 416
 417 typedef struct {
 418         SoupMessage *message;
 419         int status;
 420         RBDAAPConnection *connection;
 421 } DAAPResponseData;
 422
 423 static void
 424 actual_http_response_handler (DAAPResponseData *data)
 425 {
 426         RBDAAPConnectionPrivate *priv;
 427         GNode *structure;
 428         char *response;
 429         const char *encoding_header;
 430         char *message_path;
 431         int response_length;
 432
 433         priv = data->connection->priv;
 434         structure = NULL;
 435         response = data->message->response.body;
 436         encoding_header = NULL;
 437         response_length = data->message->response.length;
 438
 439         message_path = soup_uri_to_string (soup_message_get_uri (data->message), FALSE);
 440
 441         rb_debug ("Received response from %s: %d, %s\n",
 442                   message_path,
 443                   data->message->status_code,
 444                   data->message->reason_phrase);
 445
 446         if (data->message->response_headers) {
 447                 encoding_header = soup_message_get_header (data->message->response_headers, "Content-Encoding");
 448         }
 449
 450         if (SOUP_STATUS_IS_SUCCESSFUL (data->status) && encoding_header && strcmp (encoding_header, "gzip") == 0) {
 451 #ifdef HAVE_LIBZ
 452                 z_stream stream;
 453                 char *new_response;
 454                 unsigned int factor = 4;
 455                 unsigned int unc_size = response_length * factor;
 456
 457                 stream.next_in = (unsigned char *)response;
 458                 stream.avail_in = response_length;
 459                 stream.total_in = 0;
 460
 461                 new_response = g_malloc (unc_size + 1);
 462                 stream.next_out = (unsigned char *)new_response;
 463                 stream.avail_out = unc_size;
 464                 stream.total_out = 0;
 465                 stream.zalloc = g_zalloc_wrapper;
 466                 stream.zfree = g_zfree_wrapper;
 467                 stream.opaque = NULL;
 468
 469                 rb_profile_start ("decompressing DAAP response");
 470
 471                 if (inflateInit2 (&stream, 32 /* auto-detect */ + 15 /* max */ ) != Z_OK) {
 472                         inflateEnd (&stream);
 473                         g_free (new_response);
 474                         rb_debug ("Unable to decompress response from %s",
 475                                   message_path);
 476                         data->status = SOUP_STATUS_MALFORMED;
 477                         rb_profile_end ("decompressing DAAP response (failed)");
 478                 } else {
 479                         do {
 480                                 int z_res;
 481
 482                                 rb_profile_start ("attempting inflate");
 483                                 z_res = inflate (&stream, Z_FINISH);
 484                                 if (z_res == Z_STREAM_END) {
 485                                         rb_profile_end ("attempting inflate (done)");
 486                                         break;
 487                                 }
 488                                 if ((z_res != Z_OK && z_res != Z_BUF_ERROR) || stream.avail_out != 0 || unc_size > 40*1000*1000) {
 489                                         inflateEnd (&stream);
 490                                         g_free (new_response);
 491                                         new_response = NULL;
 492                                         rb_profile_end ("attempting inflate (error)");
 493                                         break;
 494                                 }
 495
 496                                 factor *= 4;
 497                                 unc_size = (response_length * factor);
 498                                 /* unc_size can't grow bigger than 40MB, so
 499                                  * unc_size can't overflow, and this realloc
 500                                  * call is safe
 501                                  */
 502                                 new_response = g_realloc (new_response, unc_size + 1);
 503                                 stream.next_out = (unsigned char *)(new_response + stream.total_out);
 504                                 stream.avail_out = unc_size - stream.total_out;
 505                                 rb_profile_end ("attempting inflate (incomplete)");
 506                         } while (1);
 507                 }
 508                 rb_profile_end ("decompressing DAAP response (successful)");
 509
 510                 if (new_response) {
 511                         response = new_response;
 512                         response_length = stream.total_out;
 513                 }
 514 #else
 515                 rb_debug ("Received compressed response from %s but can't handle it",
 516                           message_path);
 517                 data->status = SOUP_STATUS_MALFORMED;
 518 #endif
 519         }
 520
 521         if (SOUP_STATUS_IS_SUCCESSFUL (data->status)) {
 522                 RBDAAPItem *item;
 523
 524                 if (!rb_is_main_thread ()) {
 525                         priv->progress = -1.0f;
 526                         if (priv->emit_progress_id != 0) {
 527                                 g_source_remove (priv->emit_progress_id);
 528                         }
 529                         priv->emit_progress_id = g_idle_add ((GSourceFunc) emit_progress_idle, data->connection);
 530                 }
 531                 rb_profile_start ("parsing DAAP response");
 532                 structure = rb_daap_structure_parse (response, response_length);
 533                 if (structure == NULL) {
 534                         rb_debug ("No daap structure returned from %s",
 535                                   message_path);
 536
 537                         data->status = SOUP_STATUS_MALFORMED;
 538                         rb_profile_end ("parsing DAAP response (failed)");
 539                 } else {
 540                         int dmap_status = 0;
 541                         item = rb_daap_structure_find_item (structure, RB_DAAP_CC_MSTT);
 542                         if (item)
 543                                 dmap_status = g_value_get_int (&(item->content));
 544
 545                         if (dmap_status != 200) {
 546                                 rb_debug ("Error, dmap.status is not 200 in response from %s",
 547                                           message_path);
 548
 549                                 data->status = SOUP_STATUS_MALFORMED;
 550                         }
 551                         rb_profile_end ("parsing DAAP response (successful)");
 552                 }
 553                 if (! rb_is_main_thread ()) {
 554                         priv->progress = 1.0f;
 555                         if (priv->emit_progress_id != 0) {
 556                                 g_source_remove (priv->emit_progress_id);
 557                         }
 558                         priv->emit_progress_id = g_idle_add ((GSourceFunc) emit_progress_idle, data->connection);
 559                 }
 560         } else {
 561                 rb_debug ("Error getting %s: %d, %s\n",
 562                           message_path,
 563                           data->message->status_code,
 564                           data->message->reason_phrase);
 565                 connection_set_error_message (data->connection, data->message->reason_phrase);
 566         }
 567
 568         if (priv->response_handler) {
 569                 RBDAAPResponseHandler h = priv->response_handler;
 570                 priv->response_handler = NULL;
 571                 (*h) (data->connection, data->status, structure);
 572         }
 573
 574         if (structure) {
 575                 rb_daap_structure_destroy (structure);
 576         }
 577
 578         if (response != data->message->response.body) {
 579                 g_free (response);
 580         }
 581
 582         g_free (message_path);
 583         g_object_unref (G_OBJECT (data->connection));
 584         g_object_unref (G_OBJECT (data->message));
 585         g_free (data);
 586 }
 587
 588 static void
 589 http_response_handler (SoupMessage      *message,
 590                        RBDAAPConnection *connection)
 591 {
 592         DAAPResponseData *data;
 593         int response_length;
 594
 595         if (message->status_code == SOUP_STATUS_CANCELLED) {
 596                 rb_debug ("Message cancelled");
 597                 return;
 598         }
 599
 600         data = g_new0 (DAAPResponseData, 1);
 601         data->status = message->status_code;
 602         response_length = message->response.length;
 603
 604         g_object_ref (G_OBJECT (connection));
 605         data->connection = connection;
 606
 607         g_object_ref (G_OBJECT (message));
 608         data->message = message;
 609
 610         if (response_length >= G_MAXUINT/4 - 1) {
 611                 /* If response_length is too big,
 612                  * the g_malloc (unc_size + 1) below would overflow
 613                  */
 614                 data->status = SOUP_STATUS_MALFORMED;
 615         }
 616
 617         /* to avoid blocking the UI, handle big responses in a separate thread */
 618         if (SOUP_STATUS_IS_SUCCESSFUL (data->status) && connection->priv->use_response_handler_thread) {
 619                 GError *error = NULL;
 620                 rb_debug ("creating thread to handle daap response");
 621                 g_thread_create ((GThreadFunc) actual_http_response_handler,
 622                                  data,
 623                                  FALSE,
 624                                  &error);
 625                 if (error) {
 626                         g_warning ("fuck");
 627                 }
 628         } else {
 629                 actual_http_response_handler (data);
 630         }
 631 }
 632
 633 static gboolean
 634 http_get (RBDAAPConnection     *connection,
 635           const char           *path,
 636           gboolean              need_hash,
 637           gdouble               version,
 638           gint                  req_id,
 639           gboolean              send_close,
 640           RBDAAPResponseHandler handler,
 641           gboolean              use_thread)
 642 {
 643         RBDAAPConnectionPrivate *priv = connection->priv;
 644         SoupMessage *message;
 645
 646         message = build_message (connection, path, need_hash, version, req_id, send_close);
 647         if (message == NULL) {
 648                 rb_debug ("Error building message for http://%s:%d/%s",
 649                           priv->base_uri->host,
 650                           priv->base_uri->port,
 651                           path);
 652                 return FALSE;
 653         }
 654
 655         priv->use_response_handler_thread = use_thread;
 656         priv->response_handler = handler;
 657         soup_session_queue_message (priv->session, message,
 658                                     (SoupMessageCallbackFn) http_response_handler,
 659                                     connection);
 660         rb_debug ("Queued message for http://%s:%d/%s",
 661                   priv->base_uri->host,
 662                   priv->base_uri->port,
 663                   path);
 664         return TRUE;
 665 }
 666
 667 static void
 668 entry_set_string_prop (RhythmDB        *db,
 669                        RhythmDBEntry   *entry,
 670                        RhythmDBPropType propid,
 671                        const char      *str)
 672 {
 673         GValue value = {0,};
 674         const gchar *tmp;
 675
 676         if (str == NULL || *str == '\0' || !g_utf8_validate (str, -1, NULL)) {
 677                 tmp = _("Unknown");
 678         } else {
 679                 tmp = str;
 680         }
 681
 682         g_value_init (&value, G_TYPE_STRING);
 683         g_value_set_string (&value, tmp);
 684         rhythmdb_entry_set (RHYTHMDB (db), entry, propid, &value);
 685         g_value_unset (&value);
 686 }
 687
 688 static gboolean
 689 emit_progress_idle (RBDAAPConnection *connection)
 690 {
 691         rb_debug ("Emitting progress");
 692
 693         GDK_THREADS_ENTER ();
 694         g_signal_emit (G_OBJECT (connection), signals[CONNECTING], 0,
 695                        connection->priv->state,
 696                        connection->priv->progress);
 697         connection->priv->emit_progress_id = 0;
 698         GDK_THREADS_LEAVE ();
 699         return FALSE;
 700 }
 701
 702 static void
 703 handle_server_info (RBDAAPConnection *connection,
 704                     guint             status,
 705                     GNode            *structure)
 706 {
 707         RBDAAPConnectionPrivate *priv = connection->priv;
 708         RBDAAPItem *item = NULL;
 709
 710         if (!SOUP_STATUS_IS_SUCCESSFUL (status) || structure == NULL) {
 711                 rb_daap_connection_state_done (connection, FALSE);
 712                 return;
 713         }
 714
 715         /* get the daap version number */
 716         item = rb_daap_structure_find_item (structure, RB_DAAP_CC_APRO);
 717         if (item == NULL) {
 718                 rb_daap_connection_state_done (connection, FALSE);
 719                 return;
 720         }
 721
 722         priv->daap_version = g_value_get_double (&(item->content));
 723         rb_daap_connection_state_done (connection, TRUE);
 724 }
 725
 726 static void
 727 handle_login (RBDAAPConnection *connection,
 728               guint             status,
 729               GNode            *structure)
 730 {
 731         RBDAAPConnectionPrivate *priv = connection->priv;
 732         RBDAAPItem *item = NULL;
 733
 734         if (status == SOUP_STATUS_UNAUTHORIZED || status == SOUP_STATUS_FORBIDDEN) {
 735                 rb_debug ("Incorrect password");
 736                 priv->state = DAAP_GET_PASSWORD;
 737                 if (priv->do_something_id != 0) {
 738                         g_source_remove (priv->do_something_id);
 739                 }
 740                 priv->do_something_id = g_idle_add ((GSourceFunc) rb_daap_connection_do_something, connection);
 741                 return;
 742         }
 743
 744         if (structure == NULL || SOUP_STATUS_IS_SUCCESSFUL (status) == FALSE) {
 745                 rb_daap_connection_state_done (connection, FALSE);
 746                 return;
 747         }
 748
 749         item = rb_daap_structure_find_item (structure, RB_DAAP_CC_MLID);
 750         if (item == NULL) {
 751                 rb_debug ("Could not find daap.sessionid item in /login");
 752                 rb_daap_connection_state_done (connection, FALSE);
 753                 return;
 754         }
 755
 756         priv->session_id = (guint32) g_value_get_int (&(item->content));
 757
 758         connection_connected (connection);
 759
 760         rb_daap_connection_state_done (connection, TRUE);
 761 }
 762
 763 static void
 764 handle_update (RBDAAPConnection *connection,
 765                guint             status,
 766                GNode            *structure)
 767 {
 768         RBDAAPConnectionPrivate *priv = connection->priv;
 769         RBDAAPItem *item;
 770
 771         if (structure == NULL || SOUP_STATUS_IS_SUCCESSFUL (status) == FALSE) {
 772                 rb_daap_connection_state_done (connection, FALSE);
 773                 return;
 774         }
 775
 776         /* get a revision number */
 777         item = rb_daap_structure_find_item (structure, RB_DAAP_CC_MUSR);
 778         if (item == NULL) {
 779                 rb_debug ("Could not find daap.serverrevision item in /update");
 780                 rb_daap_connection_state_done (connection, FALSE);
 781                 return;
 782         }
 783
 784         priv->revision_number = g_value_get_int (&(item->content));
 785         rb_daap_connection_state_done (connection, TRUE);
 786 }
 787
 788 static void
 789 handle_database_info (RBDAAPConnection *connection,
 790                       guint             status,
 791                       GNode            *structure)
 792 {
 793         RBDAAPConnectionPrivate *priv = connection->priv;
 794         RBDAAPItem *item = NULL;
 795         GNode *listing_node;
 796         gint n_databases = 0;
 797
 798         /* get a list of databases, there should be only 1 */
 799
 800         if (structure == NULL || SOUP_STATUS_IS_SUCCESSFUL (status) == FALSE) {
 801                 rb_daap_connection_state_done (connection, FALSE);
 802                 return;
 803         }
 804
 805         item = rb_daap_structure_find_item (structure, RB_DAAP_CC_MRCO);
 806         if (item == NULL) {
 807                 rb_debug ("Could not find dmap.returnedcount item in /databases");
 808                 rb_daap_connection_state_done (connection, FALSE);
 809                 return;
 810         }
 811
 812         n_databases = g_value_get_int (&(item->content));
 813         if (n_databases != 1) {
 814                 rb_debug ("Host seems to have more than 1 database, how strange\n");
 815         }
 816
 817         listing_node = rb_daap_structure_find_node (structure, RB_DAAP_CC_MLCL);
 818         if (listing_node == NULL) {
 819                 rb_debug ("Could not find dmap.listing item in /databases");
 820                 rb_daap_connection_state_done (connection, FALSE);
 821                 return;
 822         }
 823
 824         item = rb_daap_structure_find_item (listing_node->children, RB_DAAP_CC_MIID);
 825         if (item == NULL) {
 826                 rb_debug ("Could not find dmap.itemid item in /databases");
 827                 rb_daap_connection_state_done (connection, FALSE);
 828                 return;
 829         }
 830
 831         priv->database_id = g_value_get_int (&(item->content));
 832         rb_daap_connection_state_done (connection, TRUE);
 833 }
 834
 835 static void
 836 handle_song_listing (RBDAAPConnection *connection,
 837                      guint             status,
 838                      GNode            *structure)
 839 {
 840         RBDAAPConnectionPrivate *priv = connection->priv;
 841         RBDAAPItem *item = NULL;
 842         GNode *listing_node;
 843         gint returned_count;
 844         gint i;
 845         GNode *n;
 846         gint specified_total_count;
 847         gboolean update_type;
 848         gint commit_batch;
 849
 850         /* get the songs */
 851
 852         if (structure == NULL || SOUP_STATUS_IS_SUCCESSFUL (status) == FALSE) {
 853                 rb_daap_connection_state_done (connection, FALSE);
 854                 return;
 855         }
 856
 857         item = rb_daap_structure_find_item (structure, RB_DAAP_CC_MRCO);
 858         if (item == NULL) {
 859                 rb_debug ("Could not find dmap.returnedcount item in /databases/%d/items",
 860                           priv->database_id);
 861                 rb_daap_connection_state_done (connection, FALSE);
 862                 return;
 863         }
 864         returned_count = g_value_get_int (&(item->content));
 865         if (returned_count > 20) {
 866                 commit_batch = returned_count / 20;
 867         } else {
 868                 commit_batch = 1;
 869         }
 870
 871         item = rb_daap_structure_find_item (structure, RB_DAAP_CC_MTCO);
 872         if (item == NULL) {
 873                 rb_debug ("Could not find dmap.specifiedtotalcount item in /databases/%d/items",
 874                           priv->database_id);
 875                 rb_daap_connection_state_done (connection, FALSE);
 876                 return;
 877         }
 878         specified_total_count = g_value_get_int (&(item->content));
 879
 880         item = rb_daap_structure_find_item (structure, RB_DAAP_CC_MUTY);
 881         if (item == NULL) {
 882                 rb_debug ("Could not find dmap.updatetype item in /databases/%d/items",
 883                           priv->database_id);
 884                 rb_daap_connection_state_done (connection, FALSE);
 885                 return;
 886         }
 887         update_type = g_value_get_char (&(item->content));
 888
 889         listing_node = rb_daap_structure_find_node (structure, RB_DAAP_CC_MLCL);
 890         if (listing_node == NULL) {
 891                 rb_debug ("Could not find dmap.listing item in /databases/%d/items",
 892                           priv->database_id);
 893                 rb_daap_connection_state_done (connection, FALSE);
 894                 return;
 895         }
 896
 897         priv->item_id_to_uri = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)rb_refstring_unref);
 898
 899         rb_profile_start ("handling song listing");
 900         priv->progress = 0.0f;
 901         if (priv->emit_progress_id != 0) {
 902                 g_source_remove (priv->emit_progress_id);
 903         }
 904         connection->priv->emit_progress_id = g_idle_add ((GSourceFunc) emit_progress_idle, connection);
 905
 906         for (i = 0, n = listing_node->children; n; i++, n = n->next) {
 907                 GNode *n2;
 908                 RhythmDBEntry *entry = NULL;
 909                 GValue value = {0,};
 910                 gchar *uri = NULL;
 911                 gint item_id = 0;
 912                 const gchar *title = NULL;
 913                 const gchar *album = NULL;
 914                 const gchar *artist = NULL;
 915                 const gchar *format = NULL;
 916                 const gchar *genre = NULL;
 917                 gint length = 0;
 918                 gint track_number = 0;
 919                 gint disc_number = 0;
 920                 gint year = 0;
 921                 gint size = 0;
 922                 gint bitrate = 0;
 923
 924                 for (n2 = n->children; n2; n2 = n2->next) {
 925                         RBDAAPItem *meta_item;
 926
 927                         meta_item = n2->data;
 928
 929                         switch (meta_item->content_code) {
 930                                 case RB_DAAP_CC_MIID:
 931                                         item_id = g_value_get_int (&(meta_item->content));
 932                                         break;
 933                                 case RB_DAAP_CC_MINM:
 934                                         title = g_value_get_string (&(meta_item->content));
 935                                         break;
 936                                 case RB_DAAP_CC_ASAL:
 937                                         album = g_value_get_string (&(meta_item->content));
 938                                         break;
 939                                 case RB_DAAP_CC_ASAR:
 940                                         artist = g_value_get_string (&(meta_item->content));
 941                                         break;
 942                                 case RB_DAAP_CC_ASFM:
 943                                         format = g_value_get_string (&(meta_item->content));
 944                                         break;
 945                                 case RB_DAAP_CC_ASGN:
 946                                         genre = g_value_get_string (&(meta_item->content));
 947                                         break;
 948                                 case RB_DAAP_CC_ASTM:
 949                                         length = g_value_get_int (&(meta_item->content));
 950                                         break;
 951                                 case RB_DAAP_CC_ASTN:
 952                                         track_number = g_value_get_int (&(meta_item->content));
 953                                         break;
 954                                 case RB_DAAP_CC_ASDN:
 955                                         disc_number = g_value_get_int (&(meta_item->content));
 956                                         break;
 957                                 case RB_DAAP_CC_ASYR:
 958                                         year = g_value_get_int (&(meta_item->content));
 959                                         break;
 960                                 case RB_DAAP_CC_ASSZ:
 961                                         size = g_value_get_int (&(meta_item->content));
 962                                         break;
 963                                 case RB_DAAP_CC_ASBR:
 964                                         bitrate = g_value_get_int (&(meta_item->content));
 965                                         break;
 966                                 default:
 967                                         break;
 968                         }
 969                 }
 970
 971                 /*if (connection->daap_version == 3.0) {*/
 972                         uri = g_strdup_printf ("%s/databases/%d/items/%d.%s?session-id=%u",
 973                                                priv->daap_base_uri,
 974                                                priv->database_id,
 975                                                item_id, format,
 976                                                priv->session_id);
 977                 /*} else {*/
 978                 /* uri should be
 979                  * "/databases/%d/items/%d.%s?session-id=%u&revision-id=%d";
 980                  * but its not going to work cause the other parts of the code
 981                  * depend on the uri to have the ip address so that the
 982                  * RBDAAPSource can be found to ++request_id
 983                  * maybe just /dont/ support older itunes.  doesn't seem
 984                  * unreasonable to me, honestly
 985                  */
 986                 /*}*/
 987                 entry = rhythmdb_entry_new (priv->db, priv->db_type, uri);
 988                 if (entry == NULL) {
 989                         rb_debug ("cannot create entry for daap track %s", uri);
 990                         continue;
 991                 }
 992                 g_hash_table_insert (priv->item_id_to_uri, GINT_TO_POINTER (item_id), rb_refstring_new (uri));
 993                 g_free (uri);
 994
 995                 /* year */
 996                 if (year != 0) {
 997                         GDate *date;
 998                         gulong julian;
 999
1000                         /* create dummy date with given year */
1001                         date = g_date_new_dmy (1, G_DATE_JANUARY, year);
1002                         julian = g_date_get_julian (date);
1003                         g_date_free (date);
1004
1005                         g_value_init (&value, G_TYPE_ULONG);
1006                         g_value_set_ulong (&value,julian);
1007                         rhythmdb_entry_set (priv->db, entry, RHYTHMDB_PROP_DATE, &value);
1008                         g_value_unset (&value);
1009                 }
1010
1011                 /* track number */
1012                 g_value_init (&value, G_TYPE_ULONG);
1013                 g_value_set_ulong (&value,(gulong)track_number);
1014                 rhythmdb_entry_set (priv->db, entry, RHYTHMDB_PROP_TRACK_NUMBER, &value);
1015                 g_value_unset (&value);
1016
1017                 /* disc number */
1018                 g_value_init (&value, G_TYPE_ULONG);
1019                 g_value_set_ulong (&value,(gulong)disc_number);
1020                 rhythmdb_entry_set (priv->db, entry, RHYTHMDB_PROP_DISC_NUMBER, &value);
1021                 g_value_unset (&value);
1022
1023                 /* bitrate */
1024                 g_value_init (&value, G_TYPE_ULONG);
1025                 g_value_set_ulong (&value,(gulong)bitrate);
1026                 rhythmdb_entry_set (priv->db, entry, RHYTHMDB_PROP_BITRATE, &value);
1027                 g_value_unset (&value);
1028
1029                 /* length */
1030                 g_value_init (&value, G_TYPE_ULONG);
1031                 g_value_set_ulong (&value,(gulong)length / 1000);
1032                 rhythmdb_entry_set (priv->db, entry, RHYTHMDB_PROP_DURATION, &value);
1033                 g_value_unset (&value);
1034
1035                 /* file size */
1036                 g_value_init (&value, G_TYPE_UINT64);
1037                 g_value_set_uint64(&value,(gint64)size);
1038                 rhythmdb_entry_set (priv->db, entry, RHYTHMDB_PROP_FILE_SIZE, &value);
1039                 g_value_unset (&value);
1040
1041                 /* title */
1042                 entry_set_string_prop (priv->db, entry, RHYTHMDB_PROP_TITLE, title);
1043
1044                 /* album */
1045                 entry_set_string_prop (priv->db, entry, RHYTHMDB_PROP_ALBUM, album);
1046
1047                 /* artist */
1048                 entry_set_string_prop (priv->db, entry, RHYTHMDB_PROP_ARTIST, artist);
1049
1050                 /* genre */
1051                 entry_set_string_prop (priv->db, entry, RHYTHMDB_PROP_GENRE, genre);
1052
1053                 if (i % commit_batch == 0) {
1054                         connection->priv->progress = ((float)i / (float)returned_count);
1055                         if (priv->emit_progress_id != 0) {
1056                                 g_source_remove (connection->priv->emit_progress_id);
1057                         }
1058                         connection->priv->emit_progress_id = g_idle_add ((GSourceFunc) emit_progress_idle, connection);
1059                         rhythmdb_commit (priv->db);
1060                 }
1061         }
1062         rhythmdb_commit (priv->db);
1063         rb_profile_end ("handling song listing");
1064
1065         rb_daap_connection_state_done (connection, TRUE);
1066 }
1067
1068 /* FIXME
1069  * what we really should do is only get a list of playlists and their ids
1070  * then when they are clicked on ('activate'd) by the user, get a list of
1071  * the files that are actually in them.  This will speed up initial daap
1072  * connection times and reduce memory consumption.
1073  */
1074
1075 static void
1076 handle_playlists (RBDAAPConnection *connection,
1077                   guint             status,
1078                   GNode            *structure)
1079 {
1080         RBDAAPConnectionPrivate *priv = connection->priv;
1081         GNode *listing_node;
1082         gint i;
1083         GNode *n;
1084
1085         if (structure == NULL || SOUP_STATUS_IS_SUCCESSFUL (status) == FALSE) {
1086                 rb_daap_connection_state_done (connection, FALSE);
1087                 return;
1088         }
1089
1090         listing_node = rb_daap_structure_find_node (structure, RB_DAAP_CC_MLCL);
1091         if (listing_node == NULL) {
1092                 rb_debug ("Could not find dmap.listing item in /databases/%d/containers",
1093                           priv->database_id);
1094                 rb_daap_connection_state_done (connection, FALSE);
1095                 return;
1096         }
1097
1098         for (i = 0, n = listing_node->children; n; n = n->next, i++) {
1099                 RBDAAPItem *item;
1100                 gint id;
1101                 gchar *name;
1102                 RBDAAPPlaylist *playlist;
1103
1104                 item = rb_daap_structure_find_item (n, RB_DAAP_CC_ABPL);
1105                 if (item != NULL) {
1106                         continue;
1107                 }
1108
1109                 item = rb_daap_structure_find_item (n, RB_DAAP_CC_MIID);
1110                 if (item == NULL) {
1111                         rb_debug ("Could not find dmap.itemid item in /databases/%d/containers",
1112                                   priv->database_id);
1113                         continue;
1114                 }
1115                 id = g_value_get_int (&(item->content));
1116
1117                 item = rb_daap_structure_find_item (n, RB_DAAP_CC_MINM);
1118                 if (item == NULL) {
1119                         rb_debug ("Could not find dmap.itemname item in /databases/%d/containers",
1120                                   priv->database_id);
1121                         continue;
1122                 }
1123                 name = g_value_dup_string (&(item->content));
1124
1125                 playlist = g_new0 (RBDAAPPlaylist, 1);
1126                 playlist->id = id;
1127                 playlist->name = name;
1128                 rb_debug ("Got playlist %p: name %s, id %d", playlist, playlist->name, playlist->id);
1129
1130                 priv->playlists = g_slist_prepend (priv->playlists, playlist);
1131         }
1132         priv->playlists = g_slist_reverse (priv->playlists);
1133
1134         rb_daap_connection_state_done (connection, TRUE);
1135 }
1136
1137 static void
1138 handle_playlist_entries (RBDAAPConnection *connection,
1139                          guint             status,
1140                          GNode            *structure)
1141 {
1142         RBDAAPConnectionPrivate *priv = connection->priv;
1143         RBDAAPPlaylist *playlist;
1144         GNode *listing_node;
1145         GNode *node;
1146         gint i;
1147         GList *playlist_uris = NULL;
1148
1149         if (structure == NULL || SOUP_STATUS_IS_SUCCESSFUL (status) == FALSE) {
1150                 rb_daap_connection_state_done (connection, FALSE);
1151                 return;
1152         }
1153
1154         playlist = (RBDAAPPlaylist *)g_slist_nth_data (priv->playlists, priv->reading_playlist);
1155         g_assert (playlist);
1156
1157         listing_node = rb_daap_structure_find_node (structure, RB_DAAP_CC_MLCL);
1158         if (listing_node == NULL) {
1159                 rb_debug ("Could not find dmap.listing item in /databases/%d/containers/%d/items",
1160                           priv->database_id, playlist->id);
1161                 rb_daap_connection_state_done (connection, FALSE);
1162                 return;
1163         }
1164
1165         rb_profile_start ("handling playlist entries");
1166         for (i = 0, node = listing_node->children; node; node = node->next, i++) {
1167                 RBRefString *item_uri;
1168                 gint playlist_item_id;
1169                 RBDAAPItem *item;
1170
1171                 item = rb_daap_structure_find_item (node, RB_DAAP_CC_MIID);
1172                 if (item == NULL) {
1173                         rb_debug ("Could not find dmap.itemid item in /databases/%d/containers/%d/items",
1174                                   priv->database_id, playlist->id);
1175                         continue;
1176                 }
1177                 playlist_item_id = g_value_get_int (&(item->content));
1178
1179                 item_uri = g_hash_table_lookup (priv->item_id_to_uri, GINT_TO_POINTER (playlist_item_id));
1180                 if (item_uri == NULL) {
1181                         rb_debug ("Entry %d in playlist %s doesn't exist in the database\n",
1182                                   playlist_item_id, playlist->name);
1183                         continue;
1184                 }
1185
1186                 playlist_uris = g_list_prepend (playlist_uris, rb_refstring_ref (item_uri));
1187         }
1188         rb_profile_end ("handling playlist entries");
1189
1190         playlist->uris = playlist_uris;
1191         rb_daap_connection_state_done (connection, TRUE);
1192 }
1193
1194 static void
1195 handle_logout (RBDAAPConnection *connection,
1196                guint             status,
1197                GNode            *structure)
1198 {
1199         connection_disconnected (connection);
1200
1201         /* is there any point handling errors here? */
1202         rb_daap_connection_state_done (connection, TRUE);
1203 }
1204
1205 RBDAAPConnection *
1206 rb_daap_connection_new (const char       *name,
1207                         const char       *host,
1208                         int               port,
1209                         gboolean          password_protected,
1210                         RhythmDB         *db,
1211                         RhythmDBEntryType type)
1212 {
1213         return g_object_new (RB_TYPE_DAAP_CONNECTION,
1214                              "name", name,
1215                              "entry-type", type,
1216                              "password-protected", password_protected,
1217                              "db", db,
1218                              "host", host,
1219                              "port", port,
1220                              NULL);
1221 }
1222
1223 gboolean
1224 rb_daap_connection_is_connected (RBDAAPConnection *connection)
1225 {
1226         g_return_val_if_fail (RB_IS_DAAP_CONNECTION (connection), FALSE);
1227
1228         return connection->priv->is_connected;
1229 }
1230
1231 typedef struct {
1232         RBDAAPConnection        *connection;
1233         RBDAAPConnectionCallback callback;
1234         gpointer                 data;
1235         GDestroyNotify           destroy;
1236 } ConnectionResponseData;
1237
1238 static void
1239 connection_response_data_free (gpointer data)
1240 {
1241         ConnectionResponseData *rdata = data;
1242
1243         g_object_unref (rdata->connection);
1244         g_free (rdata);
1245 }
1246
1247 static void
1248 connected_cb (RBDAAPConnection       *connection,
1249               ConnectionResponseData *rdata)
1250 {
1251         gboolean result;
1252
1253         rb_debug ("Connected callback");
1254
1255         connection->priv->is_connecting = FALSE;
1256
1257         g_signal_handlers_disconnect_by_func (connection,
1258                                               G_CALLBACK (connected_cb),
1259                                               rdata);
1260
1261         /* if connected then we succeeded */
1262         result = rb_daap_connection_is_connected (connection);
1263
1264         if (rdata->callback) {
1265                 rdata->callback (rdata->connection,
1266                                  result,
1267                                  rdata->connection->priv->last_error_message,
1268                                  rdata->data);
1269         }
1270
1271         if (rdata->destroy) {
1272                 rdata->destroy (rdata);
1273         }
1274 }
1275
1276 void
1277 rb_daap_connection_connect (RBDAAPConnection        *connection,
1278                             RBDAAPConnectionCallback callback,
1279                             gpointer                 user_data)
1280 {
1281         ConnectionResponseData *rdata;
1282         char                   *path;
1283
1284         g_return_if_fail (RB_IS_DAAP_CONNECTION (connection));
1285         g_return_if_fail (connection->priv->state == DAAP_GET_INFO);
1286
1287         rb_debug ("Creating new DAAP connection to %s:%d", connection->priv->host, connection->priv->port);
1288
1289         connection->priv->session = soup_session_async_new ();
1290
1291         path = g_strdup_printf ("http://%s:%d", connection->priv->host, connection->priv->port);
1292         connection->priv->base_uri = soup_uri_new (path);
1293         g_free (path);
1294
1295         if (connection->priv->base_uri == NULL) {
1296                 rb_debug ("Error parsing http://%s:%d", connection->priv->host, connection->priv->port);
1297                 /* FIXME: do callback */
1298                 return;
1299         }
1300
1301         connection->priv->daap_base_uri = g_strdup_printf ("daap://%s:%d", connection->priv->host, connection->priv->port);
1302
1303         rdata = g_new (ConnectionResponseData, 1);
1304         rdata->connection = g_object_ref (connection);
1305         rdata->callback = callback;
1306         rdata->data = user_data;
1307         rdata->destroy = connection_response_data_free;
1308         g_signal_connect (connection, "operation-done", G_CALLBACK (connected_cb), rdata);
1309
1310         if (connection->priv->do_something_id != 0) {
1311                 g_source_remove (connection->priv->do_something_id);
1312         }
1313
1314         connection->priv->is_connecting = TRUE;
1315         connection->priv->do_something_id = g_idle_add ((GSourceFunc) rb_daap_connection_do_something, connection);
1316 }
1317
1318 static void
1319 disconnected_cb (RBDAAPConnection       *connection,
1320                  ConnectionResponseData *rdata)
1321 {
1322         gboolean result;
1323
1324         rb_debug ("Disconnected callback");
1325
1326         g_signal_handlers_disconnect_by_func (connection,
1327                                               G_CALLBACK (disconnected_cb),
1328                                               rdata);
1329
1330         /* if not connected then we succeeded */
1331         result = ! rb_daap_connection_is_connected (connection);
1332
1333         if (rdata->callback) {
1334                 rdata->callback (rdata->connection,
1335                                  result,
1336                                  rdata->connection->priv->last_error_message,
1337                                  rdata->data);
1338         }
1339
1340         if (rdata->destroy) {
1341                 rdata->destroy (rdata);
1342         }
1343 }
1344
1345 static void
1346 rb_daap_connection_finish (RBDAAPConnection *connection)
1347 {
1348         g_return_if_fail (RB_IS_DAAP_CONNECTION (connection));
1349
1350         rb_debug ("DAAP finish");
1351         connection->priv->state = DAAP_DONE;
1352         connection->priv->progress = 1.0f;
1353
1354         connection_operation_done (connection);
1355 }
1356
1357 void
1358 rb_daap_connection_disconnect (RBDAAPConnection        *connection,
1359                                RBDAAPConnectionCallback callback,
1360                                gpointer                 user_data)
1361 {
1362         RBDAAPConnectionPrivate *priv = connection->priv;
1363         ConnectionResponseData  *rdata;
1364
1365         g_return_if_fail (RB_IS_DAAP_CONNECTION (connection));
1366
1367         rb_debug ("Disconnecting");
1368
1369         if (connection->priv->is_connecting) {
1370                 /* this is a special case where the async connection
1371                    hasn't returned yet so we need to force the connection
1372                    to finish */
1373                 priv->state = DAAP_DONE;
1374                 GDK_THREADS_LEAVE ();
1375                 rb_daap_connection_finish (connection);
1376                 GDK_THREADS_ENTER ();
1377         }
1378
1379         rdata = g_new (ConnectionResponseData, 1);
1380         rdata->connection = g_object_ref (connection);
1381         rdata->callback = callback;
1382         rdata->data = user_data;
1383         rdata->destroy = connection_response_data_free;
1384
1385         g_signal_connect (connection, "operation-done", G_CALLBACK (disconnected_cb), rdata);
1386
1387         if (priv->do_something_id != 0) {
1388                 g_source_remove (priv->do_something_id);
1389         }
1390
1391         if (! connection->priv->is_connected) {
1392                 priv->state = DAAP_DONE;
1393                 GDK_THREADS_LEAVE ();
1394                 rb_daap_connection_finish (connection);
1395                 GDK_THREADS_ENTER ();
1396         } else {
1397                 priv->state = DAAP_LOGOUT;
1398
1399                 priv->do_something_id = g_idle_add ((GSourceFunc) rb_daap_connection_do_something, connection);
1400         }
1401 }
1402
1403 static void
1404 rb_daap_connection_state_done (RBDAAPConnection *connection,
1405                                gboolean          result)
1406 {
1407         RBDAAPConnectionPrivate *priv = connection->priv;
1408
1409         rb_debug ("Transitioning to next state from %d", priv->state);
1410
1411         if (result == FALSE) {
1412                 priv->state = DAAP_DONE;
1413                 priv->result = FALSE;
1414         } else {
1415                 switch (priv->state) {
1416                 case DAAP_GET_PLAYLISTS:
1417                         if (priv->playlists == NULL)
1418                                 priv->state = DAAP_DONE;
1419                         else
1420                                 priv->state = DAAP_GET_PLAYLIST_ENTRIES;
1421                         break;
1422                 case DAAP_GET_PLAYLIST_ENTRIES:
1423                         /* keep reading playlists until we've got them all */
1424                         if (++priv->reading_playlist >= g_slist_length (priv->playlists))
1425                                 priv->state = DAAP_DONE;
1426                         break;
1427
1428                 case DAAP_LOGOUT:
1429                         priv->state = DAAP_DONE;
1430                         break;
1431
1432                 case DAAP_DONE:
1433                         /* uhh.. */
1434                         rb_debug ("This should never happen.");
1435                         break;
1436
1437                 default:
1438                         /* in most states, we just move on to the next */
1439                         if (priv->state > DAAP_DONE) {
1440                                 rb_debug ("This should REALLY never happen.");
1441                                 return;
1442                         }
1443                         priv->state++;
1444                         break;
1445                 }
1446
1447                 priv->progress = 1.0f;
1448                 if (connection->priv->emit_progress_id != 0) {
1449                         g_source_remove (connection->priv->emit_progress_id);
1450                 }
1451                 connection->priv->emit_progress_id = g_idle_add ((GSourceFunc) emit_progress_idle, connection);
1452         }
1453
1454         if (priv->do_something_id != 0) {
1455                 g_source_remove (priv->do_something_id);
1456         }
1457         priv->do_something_id = g_idle_add ((GSourceFunc) rb_daap_connection_do_something, connection);
1458 }
1459
1460 static gboolean
1461 rb_daap_connection_do_something (RBDAAPConnection *connection)
1462 {
1463         RBDAAPConnectionPrivate *priv = connection->priv;
1464         char *path;
1465
1466         rb_debug ("Doing something for state: %d", priv->state);
1467
1468         priv->do_something_id = 0;
1469
1470         switch (priv->state) {
1471         case DAAP_GET_INFO:
1472                 rb_debug ("Getting DAAP server info");
1473                 if (! http_get (connection, "/server-info", FALSE, 0.0, 0, FALSE,
1474                                 (RBDAAPResponseHandler) handle_server_info, FALSE)) {
1475                         rb_debug ("Could not get DAAP connection info");
1476                         rb_daap_connection_state_done (connection, FALSE);
1477                 }
1478                 break;
1479
1480         case DAAP_GET_PASSWORD:
1481                 if (priv->password_protected) {
1482                         /* FIXME this bit is still synchronous */
1483                         rb_debug ("Need a password for %s", priv->name);
1484                         g_free (priv->password);
1485                         priv->password = connection_get_password (connection);
1486
1487                         if (priv->password == NULL || priv->password[0] == '\0') {
1488                                 rb_debug ("Password entry cancelled");
1489                                 priv->result = FALSE;
1490                                 priv->state = DAAP_DONE;
1491                                 rb_daap_connection_do_something (connection);
1492                                 return FALSE;
1493                         }
1494
1495                         /* If the share went away while we were asking for the password,
1496                          * don't bother trying to log in.
1497                          */
1498                         if (priv->state != DAAP_GET_PASSWORD) {
1499                                 return FALSE;
1500                         }
1501                 }
1502
1503                 /* otherwise, fall through */
1504                 priv->state = DAAP_LOGIN;
1505
1506         case DAAP_LOGIN:
1507                 rb_debug ("Logging into DAAP server");
1508                 if (! http_get (connection, "/login", FALSE, 0.0, 0, FALSE,
1509                                (RBDAAPResponseHandler) handle_login, FALSE)) {
1510                         rb_debug ("Could not login to DAAP server");
1511                         /* FIXME: set state back to GET_PASSWORD to try again */
1512                         rb_daap_connection_state_done (connection, FALSE);
1513                 }
1514
1515                 break;
1516
1517         case DAAP_GET_REVISION_NUMBER:
1518                 rb_debug ("Getting DAAP server database revision number");
1519                 path = g_strdup_printf ("/update?session-id=%u&revision-number=1", priv->session_id);
1520                 if (! http_get (connection, path, TRUE, priv->daap_version, 0, FALSE,
1521                                (RBDAAPResponseHandler) handle_update, FALSE)) {
1522                         rb_debug ("Could not get server database revision number");
1523                         rb_daap_connection_state_done (connection, FALSE);
1524                 }
1525                 g_free (path);
1526                 break;
1527
1528         case DAAP_GET_DB_INFO:
1529                 rb_debug ("Getting DAAP database info");
1530                 path = g_strdup_printf ("/databases?session-id=%u&revision-number=%d",
1531                                         priv->session_id, priv->revision_number);
1532                 if (! http_get (connection, path, TRUE, priv->daap_version, 0, FALSE,
1533                                (RBDAAPResponseHandler) handle_database_info, FALSE)) {
1534                         rb_debug ("Could not get DAAP database info");
1535                         rb_daap_connection_state_done (connection, FALSE);
1536                 }
1537                 g_free (path);
1538                 break;
1539
1540         case DAAP_GET_SONGS:
1541                 rb_debug ("Getting DAAP song listing");
1542                 path = g_strdup_printf ("/databases/%i/items?session-id=%u&revision-number=%i"
1543                                         "&meta=dmap.itemid,dmap.itemname,daap.songalbum,"
1544                                         "daap.songartist,daap.daap.songgenre,daap.songsize,"
1545                                         "daap.songtime,daap.songtrackcount,daap.songtracknumber,"
1546                                         "daap.songyear,daap.songformat,daap.songgenre,"
1547                                         "daap.songbitrate,daap.songdiscnumber",
1548                                         priv->database_id,
1549                                         priv->session_id,
1550                                         priv->revision_number);
1551                 if (! http_get (connection, path, TRUE, priv->daap_version, 0, FALSE,
1552                                (RBDAAPResponseHandler) handle_song_listing, TRUE)) {
1553                         rb_debug ("Could not get DAAP song listing");
1554                         rb_daap_connection_state_done (connection, FALSE);
1555                 }
1556                 g_free (path);
1557                 break;
1558
1559         case DAAP_GET_PLAYLISTS:
1560                 rb_debug ("Getting DAAP playlists");
1561                 path = g_strdup_printf ("/databases/%d/containers?session-id=%u&revision-number=%d",
1562                                         priv->database_id,
1563                                         priv->session_id,
1564                                         priv->revision_number);
1565                 if (! http_get (connection, path, TRUE, priv->daap_version, 0, FALSE,
1566                                (RBDAAPResponseHandler) handle_playlists, TRUE)) {
1567                         rb_debug ("Could not get DAAP playlists");
1568                         rb_daap_connection_state_done (connection, FALSE);
1569                 }
1570                 g_free (path);
1571                 break;
1572
1573         case DAAP_GET_PLAYLIST_ENTRIES:
1574                 {
1575                         RBDAAPPlaylist *playlist =
1576                                 (RBDAAPPlaylist *) g_slist_nth_data (priv->playlists,
1577                                                                      priv->reading_playlist);
1578                         g_assert (playlist);
1579                         rb_debug ("Reading DAAP playlist %d entries", priv->reading_playlist);
1580                         path = g_strdup_printf ("/databases/%d/containers/%d/items?session-id=%u&revision-number=%d&meta=dmap.itemid",
1581                                                 priv->database_id,
1582                                                 playlist->id,
1583                                                 priv->session_id, priv->revision_number);
1584                         if (! http_get (connection, path, TRUE, priv->daap_version, 0, FALSE,
1585                                        (RBDAAPResponseHandler) handle_playlist_entries, TRUE)) {
1586                                 rb_debug ("Could not get entries for DAAP playlist %d",
1587                                           priv->reading_playlist);
1588                                 rb_daap_connection_state_done (connection, FALSE);
1589                         }
1590                         g_free (path);
1591                 }
1592                 break;
1593
1594         case DAAP_LOGOUT:
1595                 rb_debug ("Logging out of DAAP server");
1596                 path = g_strdup_printf ("/logout?session-id=%u", priv->session_id);
1597                 if (! http_get (connection, path, TRUE, priv->daap_version, 0, FALSE,
1598                                (RBDAAPResponseHandler) handle_logout, FALSE)) {
1599                         rb_debug ("Could not log out of DAAP server");
1600                         rb_daap_connection_state_done (connection, FALSE);
1601                 }
1602
1603                 g_free (path);
1604                 break;
1605
1606         case DAAP_DONE:
1607                 rb_debug ("DAAP done");
1608
1609                 rb_daap_connection_finish (connection);
1610
1611                 break;
1612         }
1613
1614         return FALSE;
1615 }
1616
1617 char *
1618 rb_daap_connection_get_headers (RBDAAPConnection *connection,
1619                                 const gchar *uri,
1620                                 gint64 bytes)
1621 {
1622         RBDAAPConnectionPrivate *priv = connection->priv;
1623         GString *headers;
1624         char hash[33] = {0};
1625         char *norb_daap_uri = (char *)uri;
1626         char *s;
1627
1628         priv->request_id++;
1629
1630         if (g_strncasecmp (uri, "daap://", 7) == 0) {
1631                 norb_daap_uri = strstr (uri, "/data");
1632         }
1633
1634         rb_daap_hash_generate ((short)floorf (priv->daap_version),
1635                                (const guchar*)norb_daap_uri, 2,
1636                                (guchar*)hash,
1637                                priv->request_id);
1638
1639         headers = g_string_new ("Accept: */*\r\n"
1640                                 "Cache-Control: no-cache\r\n"
1641                                 "User-Agent: " RB_DAAP_USER_AGENT "\r\n"
1642                                 "Accept-Language: en-us, en;q=5.0\r\n"
1643                                 "Client-DAAP-Access-Index: 2\r\n"
1644                                 "Client-DAAP-Version: 3.0\r\n");
1645         g_string_append_printf (headers,
1646                                 "Client-DAAP-Validation: %s\r\n"
1647                                 "Client-DAAP-Request-ID: %d\r\n"
1648                                 "Connection: close\r\n",
1649                                 hash, priv->request_id);
1650
1651         if (priv->password_protected) {
1652                 char *user_pass;
1653                 char *token;
1654
1655                 user_pass = g_strdup_printf ("%s:%s", priv->username, priv->password);
1656                 token = soup_base64_encode (user_pass, strlen (user_pass));
1657                 g_string_append_printf (headers, "Authentication: Basic %s\r\n", token);
1658                 g_free (token);
1659                 g_free (user_pass);
1660         }
1661
1662         if (bytes != 0) {
1663                 g_string_append_printf (headers,"Range: bytes=%"G_GINT64_FORMAT"-\r\n", bytes);
1664         }
1665
1666         s = headers->str;
1667         g_string_free (headers, FALSE);
1668
1669         return s;
1670 }
1671
1672 GSList *
1673 rb_daap_connection_get_playlists (RBDAAPConnection *connection)
1674 {
1675         return connection->priv->playlists;
1676 }
1677
1678 static void
1679 rb_daap_connection_dispose (GObject *object)
1680 {
1681         RBDAAPConnectionPrivate *priv = RB_DAAP_CONNECTION (object)->priv;
1682         GSList *l;
1683
1684         rb_debug ("DAAP connection dispose");
1685
1686         if (priv->emit_progress_id != 0) {
1687                 g_source_remove (priv->emit_progress_id);
1688                 priv->emit_progress_id = 0;
1689         }
1690
1691         if (priv->do_something_id != 0) {
1692                 g_source_remove (priv->do_something_id);
1693                 priv->do_something_id = 0;
1694         }
1695
1696         if (priv->name) {
1697                 g_free (priv->name);
1698                 priv->name = NULL;
1699         }
1700
1701         if (priv->username) {
1702                 g_free (priv->username);
1703                 priv->username = NULL;
1704         }
1705
1706         if (priv->password) {
1707                 g_free (priv->password);
1708                 priv->password = NULL;
1709         }
1710
1711         if (priv->host) {
1712                 g_free (priv->host);
1713                 priv->host = NULL;
1714         }
1715
1716         if (priv->playlists) {
1717                 for (l = priv->playlists; l; l = l->next) {
1718                         RBDAAPPlaylist *playlist = l->data;
1719
1720                         g_list_foreach (playlist->uris, (GFunc)rb_refstring_unref, NULL);
1721                         g_list_free (playlist->uris);
1722                         g_free (playlist->name);
1723                         g_free (playlist);
1724                         l->data = NULL;
1725                 }
1726                 g_slist_free (priv->playlists);
1727                 priv->playlists = NULL;
1728         }
1729
1730         if (priv->item_id_to_uri) {
1731                 g_hash_table_destroy (priv->item_id_to_uri);
1732                 priv->item_id_to_uri = NULL;
1733         }
1734
1735         if (priv->session) {
1736                 rb_debug ("Aborting all pending requests");
1737                 soup_session_abort (priv->session);
1738                 g_object_unref (G_OBJECT (priv->session));
1739                 priv->session = NULL;
1740         }
1741
1742         if (priv->base_uri) {
1743                 soup_uri_free (priv->base_uri);
1744                 priv->base_uri = NULL;
1745         }
1746
1747         if (priv->daap_base_uri) {
1748                 g_free (priv->daap_base_uri);
1749                 priv->daap_base_uri = NULL;
1750         }
1751
1752         if (priv->db) {
1753                 g_object_unref (G_OBJECT (priv->db));
1754                 priv->db = NULL;
1755         }
1756
1757         if (priv->last_error_message != NULL) {
1758                 g_free (priv->last_error_message);
1759                 priv->last_error_message = NULL;
1760         }
1761
1762         G_OBJECT_CLASS (rb_daap_connection_parent_class)->dispose (object);
1763 }
1764
1765 static void
1766 rb_daap_connection_set_property (GObject *object,
1767                                  guint prop_id,
1768                                  const GValue *value,
1769                                  GParamSpec *pspec)
1770 {
1771         RBDAAPConnectionPrivate *priv = RB_DAAP_CONNECTION (object)->priv;
1772
1773         switch (prop_id) {
1774         case PROP_NAME:
1775                 g_free (priv->name);
1776                 priv->name = g_value_dup_string (value);
1777                 break;
1778         case PROP_DB:
1779                 if (priv->db != NULL) {
1780                         g_object_unref (priv->db);
1781                 }
1782                 priv->db = RHYTHMDB (g_value_dup_object (value));
1783                 break;
1784         case PROP_PASSWORD_PROTECTED:
1785                 priv->password_protected = g_value_get_boolean (value);
1786                 break;
1787         case PROP_ENTRY_TYPE:
1788                 priv->db_type = g_value_get_boxed (value);
1789                 break;
1790         case PROP_HOST:
1791                 g_free (priv->host);
1792                 priv->host = g_value_dup_string (value);
1793                 break;
1794         case PROP_PORT:
1795                 priv->port = g_value_get_uint (value);
1796                 break;
1797         default:
1798                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1799                 break;
1800         }
1801 }
1802
1803 static void
1804 rb_daap_connection_get_property (GObject *object,
1805                                  guint prop_id,
1806                                  GValue *value,
1807                                  GParamSpec *pspec)
1808 {
1809         RBDAAPConnectionPrivate *priv = RB_DAAP_CONNECTION (object)->priv;
1810
1811         switch (prop_id) {
1812         case PROP_DB:
1813                 g_value_set_object (value, priv->db);
1814                 break;
1815         case PROP_NAME:
1816                 g_value_set_string (value, priv->name);
1817                 break;
1818         case PROP_ENTRY_TYPE:
1819                 g_value_set_boxed (value, priv->db_type);
1820                 break;
1821         case PROP_PASSWORD_PROTECTED:
1822                 g_value_set_boolean (value, priv->password_protected);
1823                 break;
1824         case PROP_HOST:
1825                 g_value_set_string (value, priv->host);
1826                 break;
1827         case PROP_PORT:
1828                 g_value_set_uint (value, priv->port);
1829                 break;
1830         default:
1831                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1832                 break;
1833         }
1834 }